1
/*

2
 * AFCS_MODEL1_mid.h

3
 *

4
 * Code generation for model "AFCS_MODEL1_sf".

5
 *

6
 * Model version              : 1.995

7
 * Simulink Coder version : 8.10 (R2016a) 10-Feb-2016

8
 * C source code generated on : Wed Aug 11 17:17:39 2021

9
 *

10
 * Target selection: rtwsfcn.tlc

11
 * Note: GRT includes extra infrastructure and instrumentation for prototyping

12
 * Embedded hardware selection: ARM Compatible->ARM Cortex

13
 * Emulation hardware selection:

14
 *    Differs from embedded hardware (MATLAB Host)

15
 * Code generation objectives: Unspecified

16
 * Validation result: Not run

17
 *

18
 * SOURCES: AFCS_MODEL1_sf.c AFCS_MODEL1_CodeReuseSubsystem.c

19
 */

20


21
#include "simstruc.h"

22
#include "AFCS_MODEL1_sf.h"

23
#if defined(MATLAB_MEX_FILE) || defined(RT_MALLOC)

24


25
static int_T RegNumInputPorts(SimStruct *S, int_T nInputPorts)

26
{

27
  _ssSetNumInputPorts(S,nInputPorts);

28
  return true;

29
}

30


31
static int_T RegNumOutputPorts(SimStruct *S, int_T nOutputPorts)

32
{

33
  _ssSetNumOutputPorts(S,nOutputPorts);

34
  return true;

35
}

36


37
static int_T FcnSetErrorStatus(const SimStruct *S, DTypeId arg2)

38
{

39
  static char msg[256];

40
  if (strlen(ssGetModelName(S)) < 128) {

41
    sprintf(msg,

42
            "S-function %s does not have a tlc file. It cannot use macros that access regDataType field in simstruct.",

43
            ssGetModelName(S));

44
  } else {

45
    sprintf(msg,

46
            "A S-function does not have a tlc file. It cannot use macros that access regDataType field in simstruct.");

47
  }

48


49
  ssSetErrorStatus(S, msg);

50
  UNUSED_PARAMETER(arg2);

51
  return 0;

52
}

53


54
#endif

55


56
/* Instance data for model: AFCS_MODEL1 */

57
void *AFCS_MODEL1_malloc(SimStruct *rts)

58
{

59
  /* Local SimStruct for the generated S-Function */

60
  LocalS *lS = (LocalS *) malloc(sizeof(LocalS));

61
  ss_VALIDATE_MEMORY(rts,lS);

62
  (void) memset((char *) lS, 0,

63
                sizeof(LocalS));

64
  ssSetUserData(rts, lS);

65


66
  /* block I/O */

67
  {

68
    void *b = malloc(sizeof(B_AFCS_MODEL1_T));

69
    ss_VALIDATE_MEMORY(rts,b);

70
    ssSetLocalBlockIO(rts, b);

71
    (void) memset(b, 0,

72
                  sizeof(B_AFCS_MODEL1_T));

73


74
    {

75
      ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->FixPtSwitch = (0ULL);

76
      ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Output = (0ULL);

77
      ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->FixPtSum1 = (0ULL);

78
      ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[0] = 0.0F;

79
      ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[1] = 0.0F;

80
      ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[2] = 0.0F;

81
      ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[3] = 0.0F;

82
    }

83
  }

84


85
  _ssSetConstBlockIO(rts, &AFCS_MODEL1_Invariant);

86


87
  /* previous zero-crossing states */

88
  {

89
    int_T i;

90
    ZCSigState *zc = (ZCSigState *) malloc(sizeof(PrevZCX_AFCS_MODEL1_T));

91
    ss_VALIDATE_MEMORY(rts,zc);

92
    _ssSetPrevZCSigState(rts, zc);

93
    for (i = 0; i < 2; i++) {

94
      zc[i] = UNINITIALIZED_ZCSIG;

95
    }

96
  }

97


98
  /* model checksums */

99
  ssSetChecksumVal(rts, 0, 3122258030U);

100
  ssSetChecksumVal(rts, 1, 1365478836U);

101
  ssSetChecksumVal(rts, 2, 3803939167U);

102
  ssSetChecksumVal(rts, 3, 1395178863U);

103


104
  {

105
    /* child S-Function registration */

106
    ssSetNumSFunctions(rts, 170);

107


108
    /* register each child */

109
    {

110
      SimStruct *childSFunctions;

111
      SimStruct **childSFunctionPtrs;

112
      childSFunctions = (SimStruct *) malloc(170 * sizeof(SimStruct));

113
      ss_VALIDATE_MEMORY(rts,childSFunctions);

114
      (void) memset((void *)childSFunctions, 0,

115
                    170*sizeof(SimStruct));

116
      childSFunctionPtrs = (SimStruct **) malloc(170 * sizeof(SimStruct *));

117
      ss_VALIDATE_MEMORY(rts,childSFunctionPtrs);

118
      _ssSetSFunctions(rts, childSFunctionPtrs);

119


120
      {

121
        int_T i;

122
        for (i = 0; i < 170; i++) {

123
          _ssSetSFunction(rts, i, &childSFunctions[i]);

124
        }

125
      }

126


127
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S174>/Generated S-Function (LagFilter_sf) */

128
      {

129
        SimStruct *childS = ssGetSFunction(rts, 0);

130


131
        /* timing info */

132
        time_T *sfcnPeriod;

133
        time_T *sfcnOffset;

134
        int_T *sfcnTsMap;

135
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

136
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

137
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

138
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

139
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

140
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

141
        (void) memset((void*)sfcnPeriod, 0,

142
                      sizeof(time_T)*1);

143
        (void) memset((void*)sfcnOffset, 0,

144
                      sizeof(time_T)*1);

145
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

146
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

147
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

148


149
        /* Set up the mdlInfo pointer */

150
# ifdef USE_RTMODEL

151


152
        {

153
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

154
              struct _ssBlkInfo2));

155
          ss_VALIDATE_MEMORY(rts,blkInfo2);

156
          ssSetBlkInfo2Ptr(childS, blkInfo2);

157
        }

158


159
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

160


161
# else

162


163
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

164


165
# endif                                /* USE_RTMODEL */

166


167
        /* Allocate memory of model methods 2 */

168
        {

169
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

170
            malloc(sizeof(struct _ssSFcnModelMethods2));

171
          ss_VALIDATE_MEMORY(rts,methods2);

172
          ssSetModelMethods2(childS, methods2);

173
        }

174


175
        /* Allocate memory of model methods 3 */

176
        {

177
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

178
            malloc(sizeof(struct _ssSFcnModelMethods3));

179
          ss_VALIDATE_MEMORY(rts,methods3);

180
          ssSetModelMethods3(childS, methods3);

181
        }

182


183
        /* Allocate memory for states auxilliary information */

184
        {

185
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

186
            (sizeof(struct _ssStatesInfo2));

187
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

188
            malloc(sizeof(ssPeriodicStatesInfo));

189
          ss_VALIDATE_MEMORY(rts,statesInfo2);

190
          ssSetStatesInfo2(childS, statesInfo2);

191
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

192
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

193
        }

194


195
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

196
          RegNumInputPorts);

197
        ssSetRegNumInputPortsFcnArg(childS,childS);

198


199
        /* inputs */

200
        {

201
          struct _ssPortInputs *inputPortInfo =

202
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

203
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

204
          _ssSetNumInputPorts(childS, 6);

205
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

206


207
          /* port 0 */

208
          {

209
            real32_T const **sfcnUPtrs = (real32_T const **)

210
              malloc(1 * sizeof(real32_T *));

211
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

212
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

213
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

214
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

215
            _ssSetInputPortNumDimensions(childS, 0, 1);

216
            ssSetInputPortWidth(childS, 0, 1);

217
          }

218


219
          /* port 1 */

220
          {

221
            int8_T const **sfcnUPtrs = (int8_T const **)

222
              malloc(1 * sizeof(int8_T *));

223
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

224
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

225
              ssGetLocalBlockIO(rts))->DataTypeConversion3_h;

226
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

227
            _ssSetInputPortNumDimensions(childS, 1, 1);

228
            ssSetInputPortWidth(childS, 1, 1);

229
          }

230


231
          /* port 2 */

232
          {

233
            real32_T const **sfcnUPtrs = (real32_T const **)

234
              malloc(1 * sizeof(real32_T *));

235
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

236
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

237
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

238
            _ssSetInputPortNumDimensions(childS, 2, 1);

239
            ssSetInputPortWidth(childS, 2, 1);

240
          }

241


242
          /* port 3 */

243
          {

244
            real32_T const **sfcnUPtrs = (real32_T const **)

245
              malloc(1 * sizeof(real32_T *));

246
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

247
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

248
              ssGetLocalBlockIO(rts))->Switch_k;

249
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

250
            _ssSetInputPortNumDimensions(childS, 3, 1);

251
            ssSetInputPortWidth(childS, 3, 1);

252
          }

253


254
          /* port 4 */

255
          {

256
            real32_T const **sfcnUPtrs = (real32_T const **)

257
              malloc(1 * sizeof(real32_T *));

258
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

259
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

260
              ssGetLocalBlockIO(rts))->Switch_k;

261
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

262
            _ssSetInputPortNumDimensions(childS, 4, 1);

263
            ssSetInputPortWidth(childS, 4, 1);

264
          }

265


266
          /* port 5 */

267
          {

268
            real32_T const **sfcnUPtrs = (real32_T const **)

269
              malloc(1 * sizeof(real32_T *));

270
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

271
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

272
              ssGetLocalBlockIO(rts))->Switch4;

273
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

274
            _ssSetInputPortNumDimensions(childS, 5, 1);

275
            ssSetInputPortWidth(childS, 5, 1);

276
          }

277
        }

278


279
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

280
          RegNumOutputPorts);

281
        ssSetRegNumOutputPortsFcnArg(childS,childS);

282


283
        /* outputs */

284
        {

285
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

286
            calloc(1, sizeof(struct _ssPortOutputs));

287
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

288
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

289
          _ssSetNumOutputPorts(childS, 1);

290


291
          /* port 0 */

292
          {

293
            _ssSetOutputPortNumDimensions(childS, 0, 1);

294
            ssSetOutputPortWidth(childS, 0, 1);

295
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

296
              ssGetLocalBlockIO(rts))->GeneratedSFunction));

297
          }

298
        }

299


300
        /* path info */

301
        _ssSetModelName(childS, "LagFilter_sf");

302
        _ssSetPath(childS,

303
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/FixthrustL/ lag filter/Generated S-Function");

304
        if (ssGetRTModel(rts) == (NULL)) {

305
          _ssSetParentSS(childS, rts);

306
          _ssSetRootSS(childS, ssGetRootSS(rts));

307
        } else {

308
          ssSetRTModel(childS,ssGetRTModel(rts));

309
          _ssSetParentSS(childS, (NULL));

310
          _ssSetRootSS(childS, childS);

311
        }

312


313
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

314


315
        /* work vectors */

316
        {

317
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

318
            (4 * sizeof(struct _ssDWorkRecord));

319
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

320
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

321
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

322
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

323
          ssSetSFcnDWork(childS, dWorkRecord);

324
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

325
          _ssSetNumDWork(childS, 4);

326


327
          /* DWORK0 */

328
          ssSetDWorkWidth(childS, 0, 1);

329
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

330
          ssSetDWorkComplexSignal(childS, 0, 0);

331
          ssSetDWorkUsedAsDState(childS, 0, 1);

332
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 147))[0]);

333


334
          /* DWORK1 */

335
          ssSetDWorkWidth(childS, 1, 1);

336
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

337
          ssSetDWorkComplexSignal(childS, 1, 0);

338
          ssSetDWorkUsedAsDState(childS, 1, 1);

339
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 148))[0]);

340


341
          /* DWORK2 */

342
          ssSetDWorkWidth(childS, 2, 1);

343
          ssSetDWorkDataType(childS, 2,SS_INT8);

344
          ssSetDWorkComplexSignal(childS, 2, 0);

345
          ssSetDWorkUsedAsDState(childS, 2, 1);

346
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 374))[0]);

347


348
          /* DWORK3 */

349
          ssSetDWorkWidth(childS, 3, 1);

350
          ssSetDWorkDataType(childS, 3,SS_INT8);

351
          ssSetDWorkComplexSignal(childS, 3, 0);

352
          ssSetDWorkUsedAsDState(childS, 3, 1);

353
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 375))[0]);

354
        }

355


356
        (childS)->regDataType.arg1 = ((void *)(childS));

357
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

358
          FcnSetErrorStatus);

359
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

360
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

361
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

362
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

363


364
        /* registration */

365
#if defined(MATLAB_MEX_FILE)

366


367
        {

368
          int_T i;

369
          mxArray *plhs[1];

370
          mxArray *prhs[4];

371
          double *pr;

372
          volatile int_T *intS = (int_T *)&childS;

373
          int_T addrlen = sizeof(SimStruct *);

374
          int_T m = addrlen/sizeof(int_T) + 1;

375
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

376
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

377
          pr = mxGetPr(prhs[1]);

378
          for (i = 0; i < m - 1; i++) {

379
            pr[i] = (double)intS[i];

380
          }

381


382
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

383
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

384
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

385


386
          /* Reset port dimensions info functions because the S-function

387
           * and accelerator mex-files explicitly set their dimensions,

388
           * i.e., they are not dynamically sized. For this case, the

389
           * mex-file is responsible for the dimensions info memory

390
           * and Simulink should not free it. This is achieved by

391
           * setting the following two methods to NULL.

392
           */

393
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

394
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

395


396
          /*

397
           * Setup function pointers and call mdlInitializeSizes via

398
           * simulink.c

399
           */

400
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

401
          mxDestroyArray(plhs[0]);

402
          mxDestroyArray(prhs[0]);

403
          mxDestroyArray(prhs[1]);

404
          mxDestroyArray(prhs[2]);

405
          mxDestroyArray(prhs[3]);

406
        }

407


408
#else

409


410
        {

411
          LagFilter_sf(childS);

412
          sfcnInitializeSizes(childS);

413
        }

414


415
#endif

416


417
        sfcnInitializeSampleTimes(childS);

418


419
        /* adjust sample time */

420
        ssSetSampleTime(childS, 0, 0.0);

421
        ssSetOffsetTime(childS, 0, 0.0);

422
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

423


424
        /* set compiled values of dynamic vector attributes */

425
        ssSetNumNonsampledZCs(childS, 0);

426


427
        /* Update connectivity flags for each port */

428
        _ssSetInputPortConnected(childS, 0, 1);

429
        _ssSetInputPortConnected(childS, 1, 1);

430
        _ssSetInputPortConnected(childS, 2, 1);

431
        _ssSetInputPortConnected(childS, 3, 1);

432
        _ssSetInputPortConnected(childS, 4, 1);

433
        _ssSetInputPortConnected(childS, 5, 1);

434
        _ssSetOutputPortConnected(childS, 0, 1);

435
        _ssSetOutputPortBeingMerged(childS, 0, 0);

436


437
        /* Update the BufferDstPort flags for each input port */

438
        _ssSetInputPortBufferDstPort(childS, 0, -1);

439
        _ssSetInputPortBufferDstPort(childS, 1, -1);

440
        _ssSetInputPortBufferDstPort(childS, 2, -1);

441
        _ssSetInputPortBufferDstPort(childS, 3, -1);

442
        _ssSetInputPortBufferDstPort(childS, 4, -1);

443
        _ssSetInputPortBufferDstPort(childS, 5, -1);

444
      }

445


446
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S186>/Generated S-Function (SaturationLimiter_sf) */

447
      {

448
        SimStruct *childS = ssGetSFunction(rts, 1);

449


450
        /* timing info */

451
        time_T *sfcnPeriod;

452
        time_T *sfcnOffset;

453
        int_T *sfcnTsMap;

454
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

455
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

456
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

457
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

458
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

459
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

460
        (void) memset((void*)sfcnPeriod, 0,

461
                      sizeof(time_T)*1);

462
        (void) memset((void*)sfcnOffset, 0,

463
                      sizeof(time_T)*1);

464
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

465
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

466
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

467


468
        /* Set up the mdlInfo pointer */

469
# ifdef USE_RTMODEL

470


471
        {

472
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

473
              struct _ssBlkInfo2));

474
          ss_VALIDATE_MEMORY(rts,blkInfo2);

475
          ssSetBlkInfo2Ptr(childS, blkInfo2);

476
        }

477


478
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

479


480
# else

481


482
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

483


484
# endif                                /* USE_RTMODEL */

485


486
        /* Allocate memory of model methods 2 */

487
        {

488
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

489
            malloc(sizeof(struct _ssSFcnModelMethods2));

490
          ss_VALIDATE_MEMORY(rts,methods2);

491
          ssSetModelMethods2(childS, methods2);

492
        }

493


494
        /* Allocate memory of model methods 3 */

495
        {

496
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

497
            malloc(sizeof(struct _ssSFcnModelMethods3));

498
          ss_VALIDATE_MEMORY(rts,methods3);

499
          ssSetModelMethods3(childS, methods3);

500
        }

501


502
        /* Allocate memory for states auxilliary information */

503
        {

504
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

505
            (sizeof(struct _ssStatesInfo2));

506
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

507
            malloc(sizeof(ssPeriodicStatesInfo));

508
          ss_VALIDATE_MEMORY(rts,statesInfo2);

509
          ssSetStatesInfo2(childS, statesInfo2);

510
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

511
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

512
        }

513


514
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

515
          RegNumInputPorts);

516
        ssSetRegNumInputPortsFcnArg(childS,childS);

517


518
        /* inputs */

519
        {

520
          struct _ssPortInputs *inputPortInfo =

521
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

522
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

523
          _ssSetNumInputPorts(childS, 3);

524
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

525


526
          /* port 0 */

527
          {

528
            real32_T const **sfcnUPtrs = (real32_T const **)

529
              malloc(1 * sizeof(real32_T *));

530
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

531
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

532
              ssGetLocalBlockIO(rts))->Sum_hq;

533
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

534
            _ssSetInputPortNumDimensions(childS, 0, 1);

535
            ssSetInputPortWidth(childS, 0, 1);

536
          }

537


538
          /* port 1 */

539
          {

540
            real32_T const **sfcnUPtrs = (real32_T const **)

541
              malloc(1 * sizeof(real32_T *));

542
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

543
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

544
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

545
            _ssSetInputPortNumDimensions(childS, 1, 1);

546
            ssSetInputPortWidth(childS, 1, 1);

547
          }

548


549
          /* port 2 */

550
          {

551
            real32_T const **sfcnUPtrs = (real32_T const **)

552
              malloc(1 * sizeof(real32_T *));

553
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

554
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

555
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

556
            _ssSetInputPortNumDimensions(childS, 2, 1);

557
            ssSetInputPortWidth(childS, 2, 1);

558
          }

559
        }

560


561
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

562
          RegNumOutputPorts);

563
        ssSetRegNumOutputPortsFcnArg(childS,childS);

564


565
        /* outputs */

566
        {

567
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

568
            calloc(1, sizeof(struct _ssPortOutputs));

569
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

570
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

571
          _ssSetNumOutputPorts(childS, 1);

572


573
          /* port 0 */

574
          {

575
            _ssSetOutputPortNumDimensions(childS, 0, 1);

576
            ssSetOutputPortWidth(childS, 0, 1);

577
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

578
              ssGetLocalBlockIO(rts))->GeneratedSFunction_c));

579
          }

580
        }

581


582
        /* path info */

583
        _ssSetModelName(childS, "SaturationLimiter_sf");

584
        _ssSetPath(childS,

585
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Saturation Limiter1/Generated S-Function");

586
        if (ssGetRTModel(rts) == (NULL)) {

587
          _ssSetParentSS(childS, rts);

588
          _ssSetRootSS(childS, ssGetRootSS(rts));

589
        } else {

590
          ssSetRTModel(childS,ssGetRTModel(rts));

591
          _ssSetParentSS(childS, (NULL));

592
          _ssSetRootSS(childS, childS);

593
        }

594


595
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

596
        (childS)->regDataType.arg1 = ((void *)(childS));

597
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

598
          FcnSetErrorStatus);

599
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

600
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

601
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

602
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

603


604
        /* registration */

605
#if defined(MATLAB_MEX_FILE)

606


607
        {

608
          int_T i;

609
          mxArray *plhs[1];

610
          mxArray *prhs[4];

611
          double *pr;

612
          volatile int_T *intS = (int_T *)&childS;

613
          int_T addrlen = sizeof(SimStruct *);

614
          int_T m = addrlen/sizeof(int_T) + 1;

615
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

616
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

617
          pr = mxGetPr(prhs[1]);

618
          for (i = 0; i < m - 1; i++) {

619
            pr[i] = (double)intS[i];

620
          }

621


622
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

623
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

624
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

625


626
          /* Reset port dimensions info functions because the S-function

627
           * and accelerator mex-files explicitly set their dimensions,

628
           * i.e., they are not dynamically sized. For this case, the

629
           * mex-file is responsible for the dimensions info memory

630
           * and Simulink should not free it. This is achieved by

631
           * setting the following two methods to NULL.

632
           */

633
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

634
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

635


636
          /*

637
           * Setup function pointers and call mdlInitializeSizes via

638
           * simulink.c

639
           */

640
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

641
          mxDestroyArray(plhs[0]);

642
          mxDestroyArray(prhs[0]);

643
          mxDestroyArray(prhs[1]);

644
          mxDestroyArray(prhs[2]);

645
          mxDestroyArray(prhs[3]);

646
        }

647


648
#else

649


650
        {

651
          SaturationLimiter_sf(childS);

652
          sfcnInitializeSizes(childS);

653
        }

654


655
#endif

656


657
        sfcnInitializeSampleTimes(childS);

658


659
        /* adjust sample time */

660
        ssSetSampleTime(childS, 0, 0.0);

661
        ssSetOffsetTime(childS, 0, 0.0);

662
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

663


664
        /* set compiled values of dynamic vector attributes */

665
        ssSetNumNonsampledZCs(childS, 0);

666


667
        /* Update connectivity flags for each port */

668
        _ssSetInputPortConnected(childS, 0, 1);

669
        _ssSetInputPortConnected(childS, 1, 1);

670
        _ssSetInputPortConnected(childS, 2, 1);

671
        _ssSetOutputPortConnected(childS, 0, 1);

672
        _ssSetOutputPortBeingMerged(childS, 0, 0);

673


674
        /* Update the BufferDstPort flags for each input port */

675
        _ssSetInputPortBufferDstPort(childS, 0, -1);

676
        _ssSetInputPortBufferDstPort(childS, 1, -1);

677
        _ssSetInputPortBufferDstPort(childS, 2, -1);

678
      }

679


680
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S188>/Generated S-Function (Gain_sf) */

681
      {

682
        SimStruct *childS = ssGetSFunction(rts, 2);

683


684
        /* timing info */

685
        time_T *sfcnPeriod;

686
        time_T *sfcnOffset;

687
        int_T *sfcnTsMap;

688
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

689
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

690
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

691
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

692
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

693
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

694
        (void) memset((void*)sfcnPeriod, 0,

695
                      sizeof(time_T)*1);

696
        (void) memset((void*)sfcnOffset, 0,

697
                      sizeof(time_T)*1);

698
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

699
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

700
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

701


702
        /* Set up the mdlInfo pointer */

703
# ifdef USE_RTMODEL

704


705
        {

706
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

707
              struct _ssBlkInfo2));

708
          ss_VALIDATE_MEMORY(rts,blkInfo2);

709
          ssSetBlkInfo2Ptr(childS, blkInfo2);

710
        }

711


712
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

713


714
# else

715


716
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

717


718
# endif                                /* USE_RTMODEL */

719


720
        /* Allocate memory of model methods 2 */

721
        {

722
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

723
            malloc(sizeof(struct _ssSFcnModelMethods2));

724
          ss_VALIDATE_MEMORY(rts,methods2);

725
          ssSetModelMethods2(childS, methods2);

726
        }

727


728
        /* Allocate memory of model methods 3 */

729
        {

730
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

731
            malloc(sizeof(struct _ssSFcnModelMethods3));

732
          ss_VALIDATE_MEMORY(rts,methods3);

733
          ssSetModelMethods3(childS, methods3);

734
        }

735


736
        /* Allocate memory for states auxilliary information */

737
        {

738
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

739
            (sizeof(struct _ssStatesInfo2));

740
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

741
            malloc(sizeof(ssPeriodicStatesInfo));

742
          ss_VALIDATE_MEMORY(rts,statesInfo2);

743
          ssSetStatesInfo2(childS, statesInfo2);

744
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

745
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

746
        }

747


748
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

749
          RegNumInputPorts);

750
        ssSetRegNumInputPortsFcnArg(childS,childS);

751


752
        /* inputs */

753
        {

754
          struct _ssPortInputs *inputPortInfo =

755
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

756
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

757
          _ssSetNumInputPorts(childS, 2);

758
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

759


760
          /* port 0 */

761
          {

762
            real32_T const **sfcnUPtrs = (real32_T const **)

763
              malloc(1 * sizeof(real32_T *));

764
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

765
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

766
              ssGetLocalBlockIO(rts))->GeneratedSFunction_c;

767
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

768
            _ssSetInputPortNumDimensions(childS, 0, 1);

769
            ssSetInputPortWidth(childS, 0, 1);

770
          }

771


772
          /* port 1 */

773
          {

774
            real32_T const **sfcnUPtrs = (real32_T const **)

775
              malloc(1 * sizeof(real32_T *));

776
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

777
            sfcnUPtrs[0] = (real32_T const *)

778
              &AFCS_MODEL1_ConstP.Constant1_Value_i;

779
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

780
            _ssSetInputPortNumDimensions(childS, 1, 1);

781
            ssSetInputPortWidth(childS, 1, 1);

782
          }

783
        }

784


785
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

786
          RegNumOutputPorts);

787
        ssSetRegNumOutputPortsFcnArg(childS,childS);

788


789
        /* outputs */

790
        {

791
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

792
            calloc(1, sizeof(struct _ssPortOutputs));

793
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

794
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

795
          _ssSetNumOutputPorts(childS, 1);

796


797
          /* port 0 */

798
          {

799
            _ssSetOutputPortNumDimensions(childS, 0, 1);

800
            ssSetOutputPortWidth(childS, 0, 1);

801
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

802
              ssGetLocalBlockIO(rts))->GeneratedSFunction_c5));

803
          }

804
        }

805


806
        /* path info */

807
        _ssSetModelName(childS, "Gain_sf");

808
        _ssSetPath(childS,

809
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/gain/Generated S-Function");

810
        if (ssGetRTModel(rts) == (NULL)) {

811
          _ssSetParentSS(childS, rts);

812
          _ssSetRootSS(childS, ssGetRootSS(rts));

813
        } else {

814
          ssSetRTModel(childS,ssGetRTModel(rts));

815
          _ssSetParentSS(childS, (NULL));

816
          _ssSetRootSS(childS, childS);

817
        }

818


819
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

820
        (childS)->regDataType.arg1 = ((void *)(childS));

821
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

822
          FcnSetErrorStatus);

823
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

824
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

825
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

826
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

827


828
        /* registration */

829
#if defined(MATLAB_MEX_FILE)

830


831
        {

832
          int_T i;

833
          mxArray *plhs[1];

834
          mxArray *prhs[4];

835
          double *pr;

836
          volatile int_T *intS = (int_T *)&childS;

837
          int_T addrlen = sizeof(SimStruct *);

838
          int_T m = addrlen/sizeof(int_T) + 1;

839
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

840
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

841
          pr = mxGetPr(prhs[1]);

842
          for (i = 0; i < m - 1; i++) {

843
            pr[i] = (double)intS[i];

844
          }

845


846
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

847
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

848
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

849


850
          /* Reset port dimensions info functions because the S-function

851
           * and accelerator mex-files explicitly set their dimensions,

852
           * i.e., they are not dynamically sized. For this case, the

853
           * mex-file is responsible for the dimensions info memory

854
           * and Simulink should not free it. This is achieved by

855
           * setting the following two methods to NULL.

856
           */

857
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

858
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

859


860
          /*

861
           * Setup function pointers and call mdlInitializeSizes via

862
           * simulink.c

863
           */

864
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

865
          mxDestroyArray(plhs[0]);

866
          mxDestroyArray(prhs[0]);

867
          mxDestroyArray(prhs[1]);

868
          mxDestroyArray(prhs[2]);

869
          mxDestroyArray(prhs[3]);

870
        }

871


872
#else

873


874
        {

875
          Gain_sf(childS);

876
          sfcnInitializeSizes(childS);

877
        }

878


879
#endif

880


881
        sfcnInitializeSampleTimes(childS);

882


883
        /* adjust sample time */

884
        ssSetSampleTime(childS, 0, 0.0);

885
        ssSetOffsetTime(childS, 0, 0.0);

886
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

887


888
        /* set compiled values of dynamic vector attributes */

889
        ssSetNumNonsampledZCs(childS, 0);

890


891
        /* Update connectivity flags for each port */

892
        _ssSetInputPortConnected(childS, 0, 1);

893
        _ssSetInputPortConnected(childS, 1, 1);

894
        _ssSetOutputPortConnected(childS, 0, 1);

895
        _ssSetOutputPortBeingMerged(childS, 0, 0);

896


897
        /* Update the BufferDstPort flags for each input port */

898
        _ssSetInputPortBufferDstPort(childS, 0, -1);

899
        _ssSetInputPortBufferDstPort(childS, 1, -1);

900
      }

901


902
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S185>/Generated S-Function (LeadLagFilter_sf) */

903
      {

904
        SimStruct *childS = ssGetSFunction(rts, 3);

905


906
        /* timing info */

907
        time_T *sfcnPeriod;

908
        time_T *sfcnOffset;

909
        int_T *sfcnTsMap;

910
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

911
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

912
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

913
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

914
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

915
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

916
        (void) memset((void*)sfcnPeriod, 0,

917
                      sizeof(time_T)*1);

918
        (void) memset((void*)sfcnOffset, 0,

919
                      sizeof(time_T)*1);

920
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

921
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

922
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

923


924
        /* Set up the mdlInfo pointer */

925
# ifdef USE_RTMODEL

926


927
        {

928
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

929
              struct _ssBlkInfo2));

930
          ss_VALIDATE_MEMORY(rts,blkInfo2);

931
          ssSetBlkInfo2Ptr(childS, blkInfo2);

932
        }

933


934
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

935


936
# else

937


938
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

939


940
# endif                                /* USE_RTMODEL */

941


942
        /* Allocate memory of model methods 2 */

943
        {

944
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

945
            malloc(sizeof(struct _ssSFcnModelMethods2));

946
          ss_VALIDATE_MEMORY(rts,methods2);

947
          ssSetModelMethods2(childS, methods2);

948
        }

949


950
        /* Allocate memory of model methods 3 */

951
        {

952
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

953
            malloc(sizeof(struct _ssSFcnModelMethods3));

954
          ss_VALIDATE_MEMORY(rts,methods3);

955
          ssSetModelMethods3(childS, methods3);

956
        }

957


958
        /* Allocate memory for states auxilliary information */

959
        {

960
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

961
            (sizeof(struct _ssStatesInfo2));

962
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

963
            malloc(sizeof(ssPeriodicStatesInfo));

964
          ss_VALIDATE_MEMORY(rts,statesInfo2);

965
          ssSetStatesInfo2(childS, statesInfo2);

966
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

967
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

968
        }

969


970
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

971
          RegNumInputPorts);

972
        ssSetRegNumInputPortsFcnArg(childS,childS);

973


974
        /* inputs */

975
        {

976
          struct _ssPortInputs *inputPortInfo =

977
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

978
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

979
          _ssSetNumInputPorts(childS, 7);

980
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

981


982
          /* port 0 */

983
          {

984
            real32_T const **sfcnUPtrs = (real32_T const **)

985
              malloc(1 * sizeof(real32_T *));

986
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

987
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

988
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

989
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

990
            _ssSetInputPortNumDimensions(childS, 0, 1);

991
            ssSetInputPortWidth(childS, 0, 1);

992
          }

993


994
          /* port 1 */

995
          {

996
            int8_T const **sfcnUPtrs = (int8_T const **)

997
              malloc(1 * sizeof(int8_T *));

998
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

999
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

1000
              ssGetLocalBlockIO(rts))->DataTypeConversion1_j;

1001
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

1002
            _ssSetInputPortNumDimensions(childS, 1, 1);

1003
            ssSetInputPortWidth(childS, 1, 1);

1004
          }

1005


1006
          /* port 2 */

1007
          {

1008
            real32_T const **sfcnUPtrs = (real32_T const **)

1009
              malloc(1 * sizeof(real32_T *));

1010
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1011
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

1012
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

1013
            _ssSetInputPortNumDimensions(childS, 2, 1);

1014
            ssSetInputPortWidth(childS, 2, 1);

1015
          }

1016


1017
          /* port 3 */

1018
          {

1019
            real32_T const **sfcnUPtrs = (real32_T const **)

1020
              malloc(1 * sizeof(real32_T *));

1021
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1022
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

1023
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

1024
            _ssSetInputPortNumDimensions(childS, 3, 1);

1025
            ssSetInputPortWidth(childS, 3, 1);

1026
          }

1027


1028
          /* port 4 */

1029
          {

1030
            real32_T const **sfcnUPtrs = (real32_T const **)

1031
              malloc(1 * sizeof(real32_T *));

1032
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1033
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1034
              ssGetLocalBlockIO(rts))->Switch_k;

1035
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

1036
            _ssSetInputPortNumDimensions(childS, 4, 1);

1037
            ssSetInputPortWidth(childS, 4, 1);

1038
          }

1039


1040
          /* port 5 */

1041
          {

1042
            real32_T const **sfcnUPtrs = (real32_T const **)

1043
              malloc(1 * sizeof(real32_T *));

1044
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1045
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1046
              ssGetLocalBlockIO(rts))->Switch_k;

1047
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

1048
            _ssSetInputPortNumDimensions(childS, 5, 1);

1049
            ssSetInputPortWidth(childS, 5, 1);

1050
          }

1051


1052
          /* port 6 */

1053
          {

1054
            real32_T const **sfcnUPtrs = (real32_T const **)

1055
              malloc(1 * sizeof(real32_T *));

1056
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1057
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1058
              ssGetLocalBlockIO(rts))->GeneratedSFunction_c5;

1059
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

1060
            _ssSetInputPortNumDimensions(childS, 6, 1);

1061
            ssSetInputPortWidth(childS, 6, 1);

1062
          }

1063
        }

1064


1065
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

1066
          RegNumOutputPorts);

1067
        ssSetRegNumOutputPortsFcnArg(childS,childS);

1068


1069
        /* outputs */

1070
        {

1071
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

1072
            calloc(1, sizeof(struct _ssPortOutputs));

1073
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

1074
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

1075
          _ssSetNumOutputPorts(childS, 1);

1076


1077
          /* port 0 */

1078
          {

1079
            _ssSetOutputPortNumDimensions(childS, 0, 1);

1080
            ssSetOutputPortWidth(childS, 0, 1);

1081
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

1082
              ssGetLocalBlockIO(rts))->GeneratedSFunction_n));

1083
          }

1084
        }

1085


1086
        /* path info */

1087
        _ssSetModelName(childS, "LeadLagFilter_sf");

1088
        _ssSetPath(childS,

1089
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Lead lag/Generated S-Function");

1090
        if (ssGetRTModel(rts) == (NULL)) {

1091
          _ssSetParentSS(childS, rts);

1092
          _ssSetRootSS(childS, ssGetRootSS(rts));

1093
        } else {

1094
          ssSetRTModel(childS,ssGetRTModel(rts));

1095
          _ssSetParentSS(childS, (NULL));

1096
          _ssSetRootSS(childS, childS);

1097
        }

1098


1099
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

1100


1101
        /* work vectors */

1102
        {

1103
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

1104
            (4 * sizeof(struct _ssDWorkRecord));

1105
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

1106
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

1107
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

1108
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

1109
          ssSetSFcnDWork(childS, dWorkRecord);

1110
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

1111
          _ssSetNumDWork(childS, 4);

1112


1113
          /* DWORK0 */

1114
          ssSetDWorkWidth(childS, 0, 1);

1115
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

1116
          ssSetDWorkComplexSignal(childS, 0, 0);

1117
          ssSetDWorkUsedAsDState(childS, 0, 1);

1118
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 149))[0]);

1119


1120
          /* DWORK1 */

1121
          ssSetDWorkWidth(childS, 1, 1);

1122
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

1123
          ssSetDWorkComplexSignal(childS, 1, 0);

1124
          ssSetDWorkUsedAsDState(childS, 1, 1);

1125
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 150))[0]);

1126


1127
          /* DWORK2 */

1128
          ssSetDWorkWidth(childS, 2, 1);

1129
          ssSetDWorkDataType(childS, 2,SS_INT8);

1130
          ssSetDWorkComplexSignal(childS, 2, 0);

1131
          ssSetDWorkUsedAsDState(childS, 2, 1);

1132
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 376))[0]);

1133


1134
          /* DWORK3 */

1135
          ssSetDWorkWidth(childS, 3, 1);

1136
          ssSetDWorkDataType(childS, 3,SS_INT8);

1137
          ssSetDWorkComplexSignal(childS, 3, 0);

1138
          ssSetDWorkUsedAsDState(childS, 3, 1);

1139
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 377))[0]);

1140
        }

1141


1142
        (childS)->regDataType.arg1 = ((void *)(childS));

1143
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

1144
          FcnSetErrorStatus);

1145
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

1146
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

1147
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

1148
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

1149


1150
        /* registration */

1151
#if defined(MATLAB_MEX_FILE)

1152


1153
        {

1154
          int_T i;

1155
          mxArray *plhs[1];

1156
          mxArray *prhs[4];

1157
          double *pr;

1158
          volatile int_T *intS = (int_T *)&childS;

1159
          int_T addrlen = sizeof(SimStruct *);

1160
          int_T m = addrlen/sizeof(int_T) + 1;

1161
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

1162
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

1163
          pr = mxGetPr(prhs[1]);

1164
          for (i = 0; i < m - 1; i++) {

1165
            pr[i] = (double)intS[i];

1166
          }

1167


1168
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

1169
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

1170
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

1171


1172
          /* Reset port dimensions info functions because the S-function

1173
           * and accelerator mex-files explicitly set their dimensions,

1174
           * i.e., they are not dynamically sized. For this case, the

1175
           * mex-file is responsible for the dimensions info memory

1176
           * and Simulink should not free it. This is achieved by

1177
           * setting the following two methods to NULL.

1178
           */

1179
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

1180
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

1181


1182
          /*

1183
           * Setup function pointers and call mdlInitializeSizes via

1184
           * simulink.c

1185
           */

1186
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

1187
          mxDestroyArray(plhs[0]);

1188
          mxDestroyArray(prhs[0]);

1189
          mxDestroyArray(prhs[1]);

1190
          mxDestroyArray(prhs[2]);

1191
          mxDestroyArray(prhs[3]);

1192
        }

1193


1194
#else

1195


1196
        {

1197
          LeadLagFilter_sf(childS);

1198
          sfcnInitializeSizes(childS);

1199
        }

1200


1201
#endif

1202


1203
        sfcnInitializeSampleTimes(childS);

1204


1205
        /* adjust sample time */

1206
        ssSetSampleTime(childS, 0, 0.0);

1207
        ssSetOffsetTime(childS, 0, 0.0);

1208
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

1209


1210
        /* set compiled values of dynamic vector attributes */

1211
        ssSetNumNonsampledZCs(childS, 0);

1212


1213
        /* Update connectivity flags for each port */

1214
        _ssSetInputPortConnected(childS, 0, 1);

1215
        _ssSetInputPortConnected(childS, 1, 1);

1216
        _ssSetInputPortConnected(childS, 2, 1);

1217
        _ssSetInputPortConnected(childS, 3, 1);

1218
        _ssSetInputPortConnected(childS, 4, 1);

1219
        _ssSetInputPortConnected(childS, 5, 1);

1220
        _ssSetInputPortConnected(childS, 6, 1);

1221
        _ssSetOutputPortConnected(childS, 0, 1);

1222
        _ssSetOutputPortBeingMerged(childS, 0, 0);

1223


1224
        /* Update the BufferDstPort flags for each input port */

1225
        _ssSetInputPortBufferDstPort(childS, 0, -1);

1226
        _ssSetInputPortBufferDstPort(childS, 1, -1);

1227
        _ssSetInputPortBufferDstPort(childS, 2, -1);

1228
        _ssSetInputPortBufferDstPort(childS, 3, -1);

1229
        _ssSetInputPortBufferDstPort(childS, 4, -1);

1230
        _ssSetInputPortBufferDstPort(childS, 5, -1);

1231
        _ssSetInputPortBufferDstPort(childS, 6, -1);

1232
      }

1233


1234
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S187>/Generated S-Function (SaturationLimiter_sf) */

1235
      {

1236
        SimStruct *childS = ssGetSFunction(rts, 4);

1237


1238
        /* timing info */

1239
        time_T *sfcnPeriod;

1240
        time_T *sfcnOffset;

1241
        int_T *sfcnTsMap;

1242
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

1243
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

1244
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

1245
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

1246
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

1247
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

1248
        (void) memset((void*)sfcnPeriod, 0,

1249
                      sizeof(time_T)*1);

1250
        (void) memset((void*)sfcnOffset, 0,

1251
                      sizeof(time_T)*1);

1252
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

1253
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

1254
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

1255


1256
        /* Set up the mdlInfo pointer */

1257
# ifdef USE_RTMODEL

1258


1259
        {

1260
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

1261
              struct _ssBlkInfo2));

1262
          ss_VALIDATE_MEMORY(rts,blkInfo2);

1263
          ssSetBlkInfo2Ptr(childS, blkInfo2);

1264
        }

1265


1266
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

1267


1268
# else

1269


1270
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

1271


1272
# endif                                /* USE_RTMODEL */

1273


1274
        /* Allocate memory of model methods 2 */

1275
        {

1276
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

1277
            malloc(sizeof(struct _ssSFcnModelMethods2));

1278
          ss_VALIDATE_MEMORY(rts,methods2);

1279
          ssSetModelMethods2(childS, methods2);

1280
        }

1281


1282
        /* Allocate memory of model methods 3 */

1283
        {

1284
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

1285
            malloc(sizeof(struct _ssSFcnModelMethods3));

1286
          ss_VALIDATE_MEMORY(rts,methods3);

1287
          ssSetModelMethods3(childS, methods3);

1288
        }

1289


1290
        /* Allocate memory for states auxilliary information */

1291
        {

1292
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

1293
            (sizeof(struct _ssStatesInfo2));

1294
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

1295
            malloc(sizeof(ssPeriodicStatesInfo));

1296
          ss_VALIDATE_MEMORY(rts,statesInfo2);

1297
          ssSetStatesInfo2(childS, statesInfo2);

1298
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

1299
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

1300
        }

1301


1302
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

1303
          RegNumInputPorts);

1304
        ssSetRegNumInputPortsFcnArg(childS,childS);

1305


1306
        /* inputs */

1307
        {

1308
          struct _ssPortInputs *inputPortInfo =

1309
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

1310
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

1311
          _ssSetNumInputPorts(childS, 3);

1312
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

1313


1314
          /* port 0 */

1315
          {

1316
            real32_T const **sfcnUPtrs = (real32_T const **)

1317
              malloc(1 * sizeof(real32_T *));

1318
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1319
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1320
              ssGetLocalBlockIO(rts))->GeneratedSFunction_n;

1321
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

1322
            _ssSetInputPortNumDimensions(childS, 0, 1);

1323
            ssSetInputPortWidth(childS, 0, 1);

1324
          }

1325


1326
          /* port 1 */

1327
          {

1328
            real32_T const **sfcnUPtrs = (real32_T const **)

1329
              malloc(1 * sizeof(real32_T *));

1330
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1331
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

1332
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

1333
            _ssSetInputPortNumDimensions(childS, 1, 1);

1334
            ssSetInputPortWidth(childS, 1, 1);

1335
          }

1336


1337
          /* port 2 */

1338
          {

1339
            real32_T const **sfcnUPtrs = (real32_T const **)

1340
              malloc(1 * sizeof(real32_T *));

1341
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1342
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled110;

1343
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

1344
            _ssSetInputPortNumDimensions(childS, 2, 1);

1345
            ssSetInputPortWidth(childS, 2, 1);

1346
          }

1347
        }

1348


1349
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

1350
          RegNumOutputPorts);

1351
        ssSetRegNumOutputPortsFcnArg(childS,childS);

1352


1353
        /* outputs */

1354
        {

1355
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

1356
            calloc(1, sizeof(struct _ssPortOutputs));

1357
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

1358
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

1359
          _ssSetNumOutputPorts(childS, 1);

1360


1361
          /* port 0 */

1362
          {

1363
            _ssSetOutputPortNumDimensions(childS, 0, 1);

1364
            ssSetOutputPortWidth(childS, 0, 1);

1365
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

1366
              ssGetLocalBlockIO(rts))->Product1_g));

1367
          }

1368
        }

1369


1370
        /* path info */

1371
        _ssSetModelName(childS, "SaturationLimiter_sf");

1372
        _ssSetPath(childS,

1373
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Saturation Limiter3/Generated S-Function");

1374
        if (ssGetRTModel(rts) == (NULL)) {

1375
          _ssSetParentSS(childS, rts);

1376
          _ssSetRootSS(childS, ssGetRootSS(rts));

1377
        } else {

1378
          ssSetRTModel(childS,ssGetRTModel(rts));

1379
          _ssSetParentSS(childS, (NULL));

1380
          _ssSetRootSS(childS, childS);

1381
        }

1382


1383
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

1384
        (childS)->regDataType.arg1 = ((void *)(childS));

1385
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

1386
          FcnSetErrorStatus);

1387
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

1388
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

1389
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

1390
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

1391


1392
        /* registration */

1393
#if defined(MATLAB_MEX_FILE)

1394


1395
        {

1396
          int_T i;

1397
          mxArray *plhs[1];

1398
          mxArray *prhs[4];

1399
          double *pr;

1400
          volatile int_T *intS = (int_T *)&childS;

1401
          int_T addrlen = sizeof(SimStruct *);

1402
          int_T m = addrlen/sizeof(int_T) + 1;

1403
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

1404
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

1405
          pr = mxGetPr(prhs[1]);

1406
          for (i = 0; i < m - 1; i++) {

1407
            pr[i] = (double)intS[i];

1408
          }

1409


1410
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

1411
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

1412
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

1413


1414
          /* Reset port dimensions info functions because the S-function

1415
           * and accelerator mex-files explicitly set their dimensions,

1416
           * i.e., they are not dynamically sized. For this case, the

1417
           * mex-file is responsible for the dimensions info memory

1418
           * and Simulink should not free it. This is achieved by

1419
           * setting the following two methods to NULL.

1420
           */

1421
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

1422
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

1423


1424
          /*

1425
           * Setup function pointers and call mdlInitializeSizes via

1426
           * simulink.c

1427
           */

1428
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

1429
          mxDestroyArray(plhs[0]);

1430
          mxDestroyArray(prhs[0]);

1431
          mxDestroyArray(prhs[1]);

1432
          mxDestroyArray(prhs[2]);

1433
          mxDestroyArray(prhs[3]);

1434
        }

1435


1436
#else

1437


1438
        {

1439
          SaturationLimiter_sf(childS);

1440
          sfcnInitializeSizes(childS);

1441
        }

1442


1443
#endif

1444


1445
        sfcnInitializeSampleTimes(childS);

1446


1447
        /* adjust sample time */

1448
        ssSetSampleTime(childS, 0, 0.0);

1449
        ssSetOffsetTime(childS, 0, 0.0);

1450
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

1451


1452
        /* set compiled values of dynamic vector attributes */

1453
        ssSetNumNonsampledZCs(childS, 0);

1454


1455
        /* Update connectivity flags for each port */

1456
        _ssSetInputPortConnected(childS, 0, 1);

1457
        _ssSetInputPortConnected(childS, 1, 1);

1458
        _ssSetInputPortConnected(childS, 2, 1);

1459
        _ssSetOutputPortConnected(childS, 0, 1);

1460
        _ssSetOutputPortBeingMerged(childS, 0, 0);

1461


1462
        /* Update the BufferDstPort flags for each input port */

1463
        _ssSetInputPortBufferDstPort(childS, 0, -1);

1464
        _ssSetInputPortBufferDstPort(childS, 1, -1);

1465
        _ssSetInputPortBufferDstPort(childS, 2, -1);

1466
      }

1467


1468
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S189>/Generated S-Function (Gain_sf) */

1469
      {

1470
        SimStruct *childS = ssGetSFunction(rts, 5);

1471


1472
        /* timing info */

1473
        time_T *sfcnPeriod;

1474
        time_T *sfcnOffset;

1475
        int_T *sfcnTsMap;

1476
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

1477
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

1478
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

1479
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

1480
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

1481
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

1482
        (void) memset((void*)sfcnPeriod, 0,

1483
                      sizeof(time_T)*1);

1484
        (void) memset((void*)sfcnOffset, 0,

1485
                      sizeof(time_T)*1);

1486
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

1487
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

1488
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

1489


1490
        /* Set up the mdlInfo pointer */

1491
# ifdef USE_RTMODEL

1492


1493
        {

1494
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

1495
              struct _ssBlkInfo2));

1496
          ss_VALIDATE_MEMORY(rts,blkInfo2);

1497
          ssSetBlkInfo2Ptr(childS, blkInfo2);

1498
        }

1499


1500
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

1501


1502
# else

1503


1504
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

1505


1506
# endif                                /* USE_RTMODEL */

1507


1508
        /* Allocate memory of model methods 2 */

1509
        {

1510
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

1511
            malloc(sizeof(struct _ssSFcnModelMethods2));

1512
          ss_VALIDATE_MEMORY(rts,methods2);

1513
          ssSetModelMethods2(childS, methods2);

1514
        }

1515


1516
        /* Allocate memory of model methods 3 */

1517
        {

1518
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

1519
            malloc(sizeof(struct _ssSFcnModelMethods3));

1520
          ss_VALIDATE_MEMORY(rts,methods3);

1521
          ssSetModelMethods3(childS, methods3);

1522
        }

1523


1524
        /* Allocate memory for states auxilliary information */

1525
        {

1526
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

1527
            (sizeof(struct _ssStatesInfo2));

1528
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

1529
            malloc(sizeof(ssPeriodicStatesInfo));

1530
          ss_VALIDATE_MEMORY(rts,statesInfo2);

1531
          ssSetStatesInfo2(childS, statesInfo2);

1532
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

1533
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

1534
        }

1535


1536
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

1537
          RegNumInputPorts);

1538
        ssSetRegNumInputPortsFcnArg(childS,childS);

1539


1540
        /* inputs */

1541
        {

1542
          struct _ssPortInputs *inputPortInfo =

1543
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

1544
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

1545
          _ssSetNumInputPorts(childS, 2);

1546
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

1547


1548
          /* port 0 */

1549
          {

1550
            real32_T const **sfcnUPtrs = (real32_T const **)

1551
              malloc(1 * sizeof(real32_T *));

1552
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1553
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1554
              ssGetLocalBlockIO(rts))->GeneratedSFunction_n;

1555
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

1556
            _ssSetInputPortNumDimensions(childS, 0, 1);

1557
            ssSetInputPortWidth(childS, 0, 1);

1558
          }

1559


1560
          /* port 1 */

1561
          {

1562
            real32_T const **sfcnUPtrs = (real32_T const **)

1563
              malloc(1 * sizeof(real32_T *));

1564
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1565
            sfcnUPtrs[0] = (real32_T const *)

1566
              &AFCS_MODEL1_ConstP.Constant2_Value_c;

1567
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

1568
            _ssSetInputPortNumDimensions(childS, 1, 1);

1569
            ssSetInputPortWidth(childS, 1, 1);

1570
          }

1571
        }

1572


1573
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

1574
          RegNumOutputPorts);

1575
        ssSetRegNumOutputPortsFcnArg(childS,childS);

1576


1577
        /* outputs */

1578
        {

1579
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

1580
            calloc(1, sizeof(struct _ssPortOutputs));

1581
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

1582
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

1583
          _ssSetNumOutputPorts(childS, 1);

1584


1585
          /* port 0 */

1586
          {

1587
            _ssSetOutputPortNumDimensions(childS, 0, 1);

1588
            ssSetOutputPortWidth(childS, 0, 1);

1589
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

1590
              ssGetLocalBlockIO(rts))->GeneratedSFunction_j));

1591
          }

1592
        }

1593


1594
        /* path info */

1595
        _ssSetModelName(childS, "Gain_sf");

1596
        _ssSetPath(childS,

1597
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/gain1/Generated S-Function");

1598
        if (ssGetRTModel(rts) == (NULL)) {

1599
          _ssSetParentSS(childS, rts);

1600
          _ssSetRootSS(childS, ssGetRootSS(rts));

1601
        } else {

1602
          ssSetRTModel(childS,ssGetRTModel(rts));

1603
          _ssSetParentSS(childS, (NULL));

1604
          _ssSetRootSS(childS, childS);

1605
        }

1606


1607
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

1608
        (childS)->regDataType.arg1 = ((void *)(childS));

1609
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

1610
          FcnSetErrorStatus);

1611
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

1612
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

1613
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

1614
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

1615


1616
        /* registration */

1617
#if defined(MATLAB_MEX_FILE)

1618


1619
        {

1620
          int_T i;

1621
          mxArray *plhs[1];

1622
          mxArray *prhs[4];

1623
          double *pr;

1624
          volatile int_T *intS = (int_T *)&childS;

1625
          int_T addrlen = sizeof(SimStruct *);

1626
          int_T m = addrlen/sizeof(int_T) + 1;

1627
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

1628
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

1629
          pr = mxGetPr(prhs[1]);

1630
          for (i = 0; i < m - 1; i++) {

1631
            pr[i] = (double)intS[i];

1632
          }

1633


1634
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

1635
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

1636
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

1637


1638
          /* Reset port dimensions info functions because the S-function

1639
           * and accelerator mex-files explicitly set their dimensions,

1640
           * i.e., they are not dynamically sized. For this case, the

1641
           * mex-file is responsible for the dimensions info memory

1642
           * and Simulink should not free it. This is achieved by

1643
           * setting the following two methods to NULL.

1644
           */

1645
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

1646
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

1647


1648
          /*

1649
           * Setup function pointers and call mdlInitializeSizes via

1650
           * simulink.c

1651
           */

1652
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

1653
          mxDestroyArray(plhs[0]);

1654
          mxDestroyArray(prhs[0]);

1655
          mxDestroyArray(prhs[1]);

1656
          mxDestroyArray(prhs[2]);

1657
          mxDestroyArray(prhs[3]);

1658
        }

1659


1660
#else

1661


1662
        {

1663
          Gain_sf(childS);

1664
          sfcnInitializeSizes(childS);

1665
        }

1666


1667
#endif

1668


1669
        sfcnInitializeSampleTimes(childS);

1670


1671
        /* adjust sample time */

1672
        ssSetSampleTime(childS, 0, 0.0);

1673
        ssSetOffsetTime(childS, 0, 0.0);

1674
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

1675


1676
        /* set compiled values of dynamic vector attributes */

1677
        ssSetNumNonsampledZCs(childS, 0);

1678


1679
        /* Update connectivity flags for each port */

1680
        _ssSetInputPortConnected(childS, 0, 1);

1681
        _ssSetInputPortConnected(childS, 1, 1);

1682
        _ssSetOutputPortConnected(childS, 0, 1);

1683
        _ssSetOutputPortBeingMerged(childS, 0, 0);

1684


1685
        /* Update the BufferDstPort flags for each input port */

1686
        _ssSetInputPortBufferDstPort(childS, 0, -1);

1687
        _ssSetInputPortBufferDstPort(childS, 1, -1);

1688
      }

1689


1690
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S184>/Generated S-Function (IntegratorLimited_sf) */

1691
      {

1692
        SimStruct *childS = ssGetSFunction(rts, 6);

1693


1694
        /* timing info */

1695
        time_T *sfcnPeriod;

1696
        time_T *sfcnOffset;

1697
        int_T *sfcnTsMap;

1698
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

1699
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

1700
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

1701
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

1702
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

1703
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

1704
        (void) memset((void*)sfcnPeriod, 0,

1705
                      sizeof(time_T)*1);

1706
        (void) memset((void*)sfcnOffset, 0,

1707
                      sizeof(time_T)*1);

1708
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

1709
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

1710
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

1711


1712
        /* Set up the mdlInfo pointer */

1713
# ifdef USE_RTMODEL

1714


1715
        {

1716
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

1717
              struct _ssBlkInfo2));

1718
          ss_VALIDATE_MEMORY(rts,blkInfo2);

1719
          ssSetBlkInfo2Ptr(childS, blkInfo2);

1720
        }

1721


1722
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

1723


1724
# else

1725


1726
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

1727


1728
# endif                                /* USE_RTMODEL */

1729


1730
        /* Allocate memory of model methods 2 */

1731
        {

1732
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

1733
            malloc(sizeof(struct _ssSFcnModelMethods2));

1734
          ss_VALIDATE_MEMORY(rts,methods2);

1735
          ssSetModelMethods2(childS, methods2);

1736
        }

1737


1738
        /* Allocate memory of model methods 3 */

1739
        {

1740
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

1741
            malloc(sizeof(struct _ssSFcnModelMethods3));

1742
          ss_VALIDATE_MEMORY(rts,methods3);

1743
          ssSetModelMethods3(childS, methods3);

1744
        }

1745


1746
        /* Allocate memory for states auxilliary information */

1747
        {

1748
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

1749
            (sizeof(struct _ssStatesInfo2));

1750
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

1751
            malloc(sizeof(ssPeriodicStatesInfo));

1752
          ss_VALIDATE_MEMORY(rts,statesInfo2);

1753
          ssSetStatesInfo2(childS, statesInfo2);

1754
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

1755
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

1756
        }

1757


1758
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

1759
          RegNumInputPorts);

1760
        ssSetRegNumInputPortsFcnArg(childS,childS);

1761


1762
        /* inputs */

1763
        {

1764
          struct _ssPortInputs *inputPortInfo =

1765
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

1766
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

1767
          _ssSetNumInputPorts(childS, 7);

1768
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

1769


1770
          /* port 0 */

1771
          {

1772
            real32_T const **sfcnUPtrs = (real32_T const **)

1773
              malloc(1 * sizeof(real32_T *));

1774
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1775
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1776
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

1777
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

1778
            _ssSetInputPortNumDimensions(childS, 0, 1);

1779
            ssSetInputPortWidth(childS, 0, 1);

1780
          }

1781


1782
          /* port 1 */

1783
          {

1784
            int8_T const **sfcnUPtrs = (int8_T const **)

1785
              malloc(1 * sizeof(int8_T *));

1786
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1787
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

1788
              ssGetLocalBlockIO(rts))->DataTypeConversion1_j;

1789
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

1790
            _ssSetInputPortNumDimensions(childS, 1, 1);

1791
            ssSetInputPortWidth(childS, 1, 1);

1792
          }

1793


1794
          /* port 2 */

1795
          {

1796
            real32_T const **sfcnUPtrs = (real32_T const **)

1797
              malloc(1 * sizeof(real32_T *));

1798
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1799
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1800
              ssGetLocalBlockIO(rts))->Add2;

1801
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

1802
            _ssSetInputPortNumDimensions(childS, 2, 1);

1803
            ssSetInputPortWidth(childS, 2, 1);

1804
          }

1805


1806
          /* port 3 */

1807
          {

1808
            real32_T const **sfcnUPtrs = (real32_T const **)

1809
              malloc(1 * sizeof(real32_T *));

1810
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1811
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1812
              ssGetLocalBlockIO(rts))->Add2;

1813
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

1814
            _ssSetInputPortNumDimensions(childS, 3, 1);

1815
            ssSetInputPortWidth(childS, 3, 1);

1816
          }

1817


1818
          /* port 4 */

1819
          {

1820
            real32_T const **sfcnUPtrs = (real32_T const **)

1821
              malloc(1 * sizeof(real32_T *));

1822
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1823
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1824
              ssGetLocalBlockIO(rts))->Add_g1;

1825
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

1826
            _ssSetInputPortNumDimensions(childS, 4, 1);

1827
            ssSetInputPortWidth(childS, 4, 1);

1828
          }

1829


1830
          /* port 5 */

1831
          {

1832
            real32_T const **sfcnUPtrs = (real32_T const **)

1833
              malloc(1 * sizeof(real32_T *));

1834
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1835
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1836
              ssGetLocalBlockIO(rts))->Add1;

1837
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

1838
            _ssSetInputPortNumDimensions(childS, 5, 1);

1839
            ssSetInputPortWidth(childS, 5, 1);

1840
          }

1841


1842
          /* port 6 */

1843
          {

1844
            real32_T const **sfcnUPtrs = (real32_T const **)

1845
              malloc(1 * sizeof(real32_T *));

1846
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

1847
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

1848
              ssGetLocalBlockIO(rts))->GeneratedSFunction_j;

1849
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

1850
            _ssSetInputPortNumDimensions(childS, 6, 1);

1851
            ssSetInputPortWidth(childS, 6, 1);

1852
          }

1853
        }

1854


1855
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

1856
          RegNumOutputPorts);

1857
        ssSetRegNumOutputPortsFcnArg(childS,childS);

1858


1859
        /* outputs */

1860
        {

1861
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

1862
            calloc(1, sizeof(struct _ssPortOutputs));

1863
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

1864
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

1865
          _ssSetNumOutputPorts(childS, 1);

1866


1867
          /* port 0 */

1868
          {

1869
            _ssSetOutputPortNumDimensions(childS, 0, 1);

1870
            ssSetOutputPortWidth(childS, 0, 1);

1871
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

1872
              ssGetLocalBlockIO(rts))->Product1_g));

1873
          }

1874
        }

1875


1876
        /* path info */

1877
        _ssSetModelName(childS, "IntegratorLimited_sf");

1878
        _ssSetPath(childS,

1879
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Integrator Limited/Generated S-Function");

1880
        if (ssGetRTModel(rts) == (NULL)) {

1881
          _ssSetParentSS(childS, rts);

1882
          _ssSetRootSS(childS, ssGetRootSS(rts));

1883
        } else {

1884
          ssSetRTModel(childS,ssGetRTModel(rts));

1885
          _ssSetParentSS(childS, (NULL));

1886
          _ssSetRootSS(childS, childS);

1887
        }

1888


1889
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

1890


1891
        /* work vectors */

1892
        {

1893
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

1894
            (4 * sizeof(struct _ssDWorkRecord));

1895
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

1896
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

1897
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

1898
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

1899
          ssSetSFcnDWork(childS, dWorkRecord);

1900
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

1901
          _ssSetNumDWork(childS, 4);

1902


1903
          /* DWORK0 */

1904
          ssSetDWorkWidth(childS, 0, 1);

1905
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

1906
          ssSetDWorkComplexSignal(childS, 0, 0);

1907
          ssSetDWorkUsedAsDState(childS, 0, 1);

1908
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 151))[0]);

1909


1910
          /* DWORK1 */

1911
          ssSetDWorkWidth(childS, 1, 1);

1912
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

1913
          ssSetDWorkComplexSignal(childS, 1, 0);

1914
          ssSetDWorkUsedAsDState(childS, 1, 1);

1915
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 152))[0]);

1916


1917
          /* DWORK2 */

1918
          ssSetDWorkWidth(childS, 2, 1);

1919
          ssSetDWorkDataType(childS, 2,SS_INT8);

1920
          ssSetDWorkComplexSignal(childS, 2, 0);

1921
          ssSetDWorkUsedAsDState(childS, 2, 1);

1922
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 378))[0]);

1923


1924
          /* DWORK3 */

1925
          ssSetDWorkWidth(childS, 3, 1);

1926
          ssSetDWorkDataType(childS, 3,SS_INT8);

1927
          ssSetDWorkComplexSignal(childS, 3, 0);

1928
          ssSetDWorkUsedAsDState(childS, 3, 1);

1929
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 379))[0]);

1930
        }

1931


1932
        (childS)->regDataType.arg1 = ((void *)(childS));

1933
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

1934
          FcnSetErrorStatus);

1935
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

1936
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

1937
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

1938
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

1939


1940
        /* registration */

1941
#if defined(MATLAB_MEX_FILE)

1942


1943
        {

1944
          int_T i;

1945
          mxArray *plhs[1];

1946
          mxArray *prhs[4];

1947
          double *pr;

1948
          volatile int_T *intS = (int_T *)&childS;

1949
          int_T addrlen = sizeof(SimStruct *);

1950
          int_T m = addrlen/sizeof(int_T) + 1;

1951
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

1952
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

1953
          pr = mxGetPr(prhs[1]);

1954
          for (i = 0; i < m - 1; i++) {

1955
            pr[i] = (double)intS[i];

1956
          }

1957


1958
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

1959
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

1960
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

1961


1962
          /* Reset port dimensions info functions because the S-function

1963
           * and accelerator mex-files explicitly set their dimensions,

1964
           * i.e., they are not dynamically sized. For this case, the

1965
           * mex-file is responsible for the dimensions info memory

1966
           * and Simulink should not free it. This is achieved by

1967
           * setting the following two methods to NULL.

1968
           */

1969
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

1970
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

1971


1972
          /*

1973
           * Setup function pointers and call mdlInitializeSizes via

1974
           * simulink.c

1975
           */

1976
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

1977
          mxDestroyArray(plhs[0]);

1978
          mxDestroyArray(prhs[0]);

1979
          mxDestroyArray(prhs[1]);

1980
          mxDestroyArray(prhs[2]);

1981
          mxDestroyArray(prhs[3]);

1982
        }

1983


1984
#else

1985


1986
        {

1987
          IntegratorLimited_sf(childS);

1988
          sfcnInitializeSizes(childS);

1989
        }

1990


1991
#endif

1992


1993
        sfcnInitializeSampleTimes(childS);

1994


1995
        /* adjust sample time */

1996
        ssSetSampleTime(childS, 0, 0.0);

1997
        ssSetOffsetTime(childS, 0, 0.0);

1998
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

1999


2000
        /* set compiled values of dynamic vector attributes */

2001
        ssSetNumNonsampledZCs(childS, 0);

2002


2003
        /* Update connectivity flags for each port */

2004
        _ssSetInputPortConnected(childS, 0, 1);

2005
        _ssSetInputPortConnected(childS, 1, 1);

2006
        _ssSetInputPortConnected(childS, 2, 1);

2007
        _ssSetInputPortConnected(childS, 3, 1);

2008
        _ssSetInputPortConnected(childS, 4, 1);

2009
        _ssSetInputPortConnected(childS, 5, 1);

2010
        _ssSetInputPortConnected(childS, 6, 1);

2011
        _ssSetOutputPortConnected(childS, 0, 1);

2012
        _ssSetOutputPortBeingMerged(childS, 0, 0);

2013


2014
        /* Update the BufferDstPort flags for each input port */

2015
        _ssSetInputPortBufferDstPort(childS, 0, -1);

2016
        _ssSetInputPortBufferDstPort(childS, 1, -1);

2017
        _ssSetInputPortBufferDstPort(childS, 2, -1);

2018
        _ssSetInputPortBufferDstPort(childS, 3, -1);

2019
        _ssSetInputPortBufferDstPort(childS, 4, -1);

2020
        _ssSetInputPortBufferDstPort(childS, 5, -1);

2021
        _ssSetInputPortBufferDstPort(childS, 6, -1);

2022
      }

2023


2024
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S183>/Generated S-Function (LagFilter_sf) */

2025
      {

2026
        SimStruct *childS = ssGetSFunction(rts, 7);

2027


2028
        /* timing info */

2029
        time_T *sfcnPeriod;

2030
        time_T *sfcnOffset;

2031
        int_T *sfcnTsMap;

2032
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

2033
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

2034
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

2035
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

2036
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

2037
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

2038
        (void) memset((void*)sfcnPeriod, 0,

2039
                      sizeof(time_T)*1);

2040
        (void) memset((void*)sfcnOffset, 0,

2041
                      sizeof(time_T)*1);

2042
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

2043
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

2044
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

2045


2046
        /* Set up the mdlInfo pointer */

2047
# ifdef USE_RTMODEL

2048


2049
        {

2050
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

2051
              struct _ssBlkInfo2));

2052
          ss_VALIDATE_MEMORY(rts,blkInfo2);

2053
          ssSetBlkInfo2Ptr(childS, blkInfo2);

2054
        }

2055


2056
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

2057


2058
# else

2059


2060
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

2061


2062
# endif                                /* USE_RTMODEL */

2063


2064
        /* Allocate memory of model methods 2 */

2065
        {

2066
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

2067
            malloc(sizeof(struct _ssSFcnModelMethods2));

2068
          ss_VALIDATE_MEMORY(rts,methods2);

2069
          ssSetModelMethods2(childS, methods2);

2070
        }

2071


2072
        /* Allocate memory of model methods 3 */

2073
        {

2074
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

2075
            malloc(sizeof(struct _ssSFcnModelMethods3));

2076
          ss_VALIDATE_MEMORY(rts,methods3);

2077
          ssSetModelMethods3(childS, methods3);

2078
        }

2079


2080
        /* Allocate memory for states auxilliary information */

2081
        {

2082
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

2083
            (sizeof(struct _ssStatesInfo2));

2084
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

2085
            malloc(sizeof(ssPeriodicStatesInfo));

2086
          ss_VALIDATE_MEMORY(rts,statesInfo2);

2087
          ssSetStatesInfo2(childS, statesInfo2);

2088
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

2089
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

2090
        }

2091


2092
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

2093
          RegNumInputPorts);

2094
        ssSetRegNumInputPortsFcnArg(childS,childS);

2095


2096
        /* inputs */

2097
        {

2098
          struct _ssPortInputs *inputPortInfo =

2099
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

2100
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

2101
          _ssSetNumInputPorts(childS, 6);

2102
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

2103


2104
          /* port 0 */

2105
          {

2106
            real32_T const **sfcnUPtrs = (real32_T const **)

2107
              malloc(1 * sizeof(real32_T *));

2108
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2109
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2110
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

2111
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

2112
            _ssSetInputPortNumDimensions(childS, 0, 1);

2113
            ssSetInputPortWidth(childS, 0, 1);

2114
          }

2115


2116
          /* port 1 */

2117
          {

2118
            int8_T const **sfcnUPtrs = (int8_T const **)

2119
              malloc(1 * sizeof(int8_T *));

2120
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2121
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

2122
              ssGetLocalBlockIO(rts))->DataTypeConversion1_j;

2123
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

2124
            _ssSetInputPortNumDimensions(childS, 1, 1);

2125
            ssSetInputPortWidth(childS, 1, 1);

2126
          }

2127


2128
          /* port 2 */

2129
          {

2130
            real32_T const **sfcnUPtrs = (real32_T const **)

2131
              malloc(1 * sizeof(real32_T *));

2132
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2133
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

2134
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

2135
            _ssSetInputPortNumDimensions(childS, 2, 1);

2136
            ssSetInputPortWidth(childS, 2, 1);

2137
          }

2138


2139
          /* port 3 */

2140
          {

2141
            real32_T const **sfcnUPtrs = (real32_T const **)

2142
              malloc(1 * sizeof(real32_T *));

2143
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2144
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2145
              ssGetLocalBlockIO(rts))->Switch_k;

2146
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

2147
            _ssSetInputPortNumDimensions(childS, 3, 1);

2148
            ssSetInputPortWidth(childS, 3, 1);

2149
          }

2150


2151
          /* port 4 */

2152
          {

2153
            real32_T const **sfcnUPtrs = (real32_T const **)

2154
              malloc(1 * sizeof(real32_T *));

2155
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2156
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2157
              ssGetLocalBlockIO(rts))->Switch_k;

2158
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

2159
            _ssSetInputPortNumDimensions(childS, 4, 1);

2160
            ssSetInputPortWidth(childS, 4, 1);

2161
          }

2162


2163
          /* port 5 */

2164
          {

2165
            real32_T const **sfcnUPtrs = (real32_T const **)

2166
              malloc(1 * sizeof(real32_T *));

2167
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2168
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2169
              ssGetLocalBlockIO(rts))->Sum1_b;

2170
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

2171
            _ssSetInputPortNumDimensions(childS, 5, 1);

2172
            ssSetInputPortWidth(childS, 5, 1);

2173
          }

2174
        }

2175


2176
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

2177
          RegNumOutputPorts);

2178
        ssSetRegNumOutputPortsFcnArg(childS,childS);

2179


2180
        /* outputs */

2181
        {

2182
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

2183
            calloc(1, sizeof(struct _ssPortOutputs));

2184
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

2185
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

2186
          _ssSetNumOutputPorts(childS, 1);

2187


2188
          /* port 0 */

2189
          {

2190
            _ssSetOutputPortNumDimensions(childS, 0, 1);

2191
            ssSetOutputPortWidth(childS, 0, 1);

2192
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

2193
              ssGetLocalBlockIO(rts))->GeneratedSFunction_k));

2194
          }

2195
        }

2196


2197
        /* path info */

2198
        _ssSetModelName(childS, "LagFilter_sf");

2199
        _ssSetPath(childS,

2200
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/ lag filter/Generated S-Function");

2201
        if (ssGetRTModel(rts) == (NULL)) {

2202
          _ssSetParentSS(childS, rts);

2203
          _ssSetRootSS(childS, ssGetRootSS(rts));

2204
        } else {

2205
          ssSetRTModel(childS,ssGetRTModel(rts));

2206
          _ssSetParentSS(childS, (NULL));

2207
          _ssSetRootSS(childS, childS);

2208
        }

2209


2210
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

2211


2212
        /* work vectors */

2213
        {

2214
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

2215
            (4 * sizeof(struct _ssDWorkRecord));

2216
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

2217
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

2218
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

2219
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

2220
          ssSetSFcnDWork(childS, dWorkRecord);

2221
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

2222
          _ssSetNumDWork(childS, 4);

2223


2224
          /* DWORK0 */

2225
          ssSetDWorkWidth(childS, 0, 1);

2226
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

2227
          ssSetDWorkComplexSignal(childS, 0, 0);

2228
          ssSetDWorkUsedAsDState(childS, 0, 1);

2229
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 153))[0]);

2230


2231
          /* DWORK1 */

2232
          ssSetDWorkWidth(childS, 1, 1);

2233
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

2234
          ssSetDWorkComplexSignal(childS, 1, 0);

2235
          ssSetDWorkUsedAsDState(childS, 1, 1);

2236
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 154))[0]);

2237


2238
          /* DWORK2 */

2239
          ssSetDWorkWidth(childS, 2, 1);

2240
          ssSetDWorkDataType(childS, 2,SS_INT8);

2241
          ssSetDWorkComplexSignal(childS, 2, 0);

2242
          ssSetDWorkUsedAsDState(childS, 2, 1);

2243
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 380))[0]);

2244


2245
          /* DWORK3 */

2246
          ssSetDWorkWidth(childS, 3, 1);

2247
          ssSetDWorkDataType(childS, 3,SS_INT8);

2248
          ssSetDWorkComplexSignal(childS, 3, 0);

2249
          ssSetDWorkUsedAsDState(childS, 3, 1);

2250
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 381))[0]);

2251
        }

2252


2253
        (childS)->regDataType.arg1 = ((void *)(childS));

2254
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

2255
          FcnSetErrorStatus);

2256
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

2257
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

2258
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

2259
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

2260


2261
        /* registration */

2262
#if defined(MATLAB_MEX_FILE)

2263


2264
        {

2265
          int_T i;

2266
          mxArray *plhs[1];

2267
          mxArray *prhs[4];

2268
          double *pr;

2269
          volatile int_T *intS = (int_T *)&childS;

2270
          int_T addrlen = sizeof(SimStruct *);

2271
          int_T m = addrlen/sizeof(int_T) + 1;

2272
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

2273
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

2274
          pr = mxGetPr(prhs[1]);

2275
          for (i = 0; i < m - 1; i++) {

2276
            pr[i] = (double)intS[i];

2277
          }

2278


2279
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

2280
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

2281
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

2282


2283
          /* Reset port dimensions info functions because the S-function

2284
           * and accelerator mex-files explicitly set their dimensions,

2285
           * i.e., they are not dynamically sized. For this case, the

2286
           * mex-file is responsible for the dimensions info memory

2287
           * and Simulink should not free it. This is achieved by

2288
           * setting the following two methods to NULL.

2289
           */

2290
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

2291
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

2292


2293
          /*

2294
           * Setup function pointers and call mdlInitializeSizes via

2295
           * simulink.c

2296
           */

2297
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

2298
          mxDestroyArray(plhs[0]);

2299
          mxDestroyArray(prhs[0]);

2300
          mxDestroyArray(prhs[1]);

2301
          mxDestroyArray(prhs[2]);

2302
          mxDestroyArray(prhs[3]);

2303
        }

2304


2305
#else

2306


2307
        {

2308
          LagFilter_sf(childS);

2309
          sfcnInitializeSizes(childS);

2310
        }

2311


2312
#endif

2313


2314
        sfcnInitializeSampleTimes(childS);

2315


2316
        /* adjust sample time */

2317
        ssSetSampleTime(childS, 0, 0.0);

2318
        ssSetOffsetTime(childS, 0, 0.0);

2319
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

2320


2321
        /* set compiled values of dynamic vector attributes */

2322
        ssSetNumNonsampledZCs(childS, 0);

2323


2324
        /* Update connectivity flags for each port */

2325
        _ssSetInputPortConnected(childS, 0, 1);

2326
        _ssSetInputPortConnected(childS, 1, 1);

2327
        _ssSetInputPortConnected(childS, 2, 1);

2328
        _ssSetInputPortConnected(childS, 3, 1);

2329
        _ssSetInputPortConnected(childS, 4, 1);

2330
        _ssSetInputPortConnected(childS, 5, 1);

2331
        _ssSetOutputPortConnected(childS, 0, 1);

2332
        _ssSetOutputPortBeingMerged(childS, 0, 0);

2333


2334
        /* Update the BufferDstPort flags for each input port */

2335
        _ssSetInputPortBufferDstPort(childS, 0, -1);

2336
        _ssSetInputPortBufferDstPort(childS, 1, -1);

2337
        _ssSetInputPortBufferDstPort(childS, 2, -1);

2338
        _ssSetInputPortBufferDstPort(childS, 3, -1);

2339
        _ssSetInputPortBufferDstPort(childS, 4, -1);

2340
        _ssSetInputPortBufferDstPort(childS, 5, -1);

2341
      }

2342


2343
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S179>/Generated S-Function (SaturationLimiter_sf) */

2344
      {

2345
        SimStruct *childS = ssGetSFunction(rts, 8);

2346


2347
        /* timing info */

2348
        time_T *sfcnPeriod;

2349
        time_T *sfcnOffset;

2350
        int_T *sfcnTsMap;

2351
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

2352
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

2353
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

2354
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

2355
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

2356
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

2357
        (void) memset((void*)sfcnPeriod, 0,

2358
                      sizeof(time_T)*1);

2359
        (void) memset((void*)sfcnOffset, 0,

2360
                      sizeof(time_T)*1);

2361
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

2362
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

2363
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

2364


2365
        /* Set up the mdlInfo pointer */

2366
# ifdef USE_RTMODEL

2367


2368
        {

2369
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

2370
              struct _ssBlkInfo2));

2371
          ss_VALIDATE_MEMORY(rts,blkInfo2);

2372
          ssSetBlkInfo2Ptr(childS, blkInfo2);

2373
        }

2374


2375
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

2376


2377
# else

2378


2379
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

2380


2381
# endif                                /* USE_RTMODEL */

2382


2383
        /* Allocate memory of model methods 2 */

2384
        {

2385
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

2386
            malloc(sizeof(struct _ssSFcnModelMethods2));

2387
          ss_VALIDATE_MEMORY(rts,methods2);

2388
          ssSetModelMethods2(childS, methods2);

2389
        }

2390


2391
        /* Allocate memory of model methods 3 */

2392
        {

2393
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

2394
            malloc(sizeof(struct _ssSFcnModelMethods3));

2395
          ss_VALIDATE_MEMORY(rts,methods3);

2396
          ssSetModelMethods3(childS, methods3);

2397
        }

2398


2399
        /* Allocate memory for states auxilliary information */

2400
        {

2401
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

2402
            (sizeof(struct _ssStatesInfo2));

2403
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

2404
            malloc(sizeof(ssPeriodicStatesInfo));

2405
          ss_VALIDATE_MEMORY(rts,statesInfo2);

2406
          ssSetStatesInfo2(childS, statesInfo2);

2407
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

2408
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

2409
        }

2410


2411
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

2412
          RegNumInputPorts);

2413
        ssSetRegNumInputPortsFcnArg(childS,childS);

2414


2415
        /* inputs */

2416
        {

2417
          struct _ssPortInputs *inputPortInfo =

2418
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

2419
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

2420
          _ssSetNumInputPorts(childS, 3);

2421
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

2422


2423
          /* port 0 */

2424
          {

2425
            real32_T const **sfcnUPtrs = (real32_T const **)

2426
              malloc(1 * sizeof(real32_T *));

2427
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2428
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2429
              ssGetLocalBlockIO(rts))->Sum_mj;

2430
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

2431
            _ssSetInputPortNumDimensions(childS, 0, 1);

2432
            ssSetInputPortWidth(childS, 0, 1);

2433
          }

2434


2435
          /* port 1 */

2436
          {

2437
            real32_T const **sfcnUPtrs = (real32_T const **)

2438
              malloc(1 * sizeof(real32_T *));

2439
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2440
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

2441
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

2442
            _ssSetInputPortNumDimensions(childS, 1, 1);

2443
            ssSetInputPortWidth(childS, 1, 1);

2444
          }

2445


2446
          /* port 2 */

2447
          {

2448
            real32_T const **sfcnUPtrs = (real32_T const **)

2449
              malloc(1 * sizeof(real32_T *));

2450
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2451
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

2452
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

2453
            _ssSetInputPortNumDimensions(childS, 2, 1);

2454
            ssSetInputPortWidth(childS, 2, 1);

2455
          }

2456
        }

2457


2458
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

2459
          RegNumOutputPorts);

2460
        ssSetRegNumOutputPortsFcnArg(childS,childS);

2461


2462
        /* outputs */

2463
        {

2464
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

2465
            calloc(1, sizeof(struct _ssPortOutputs));

2466
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

2467
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

2468
          _ssSetNumOutputPorts(childS, 1);

2469


2470
          /* port 0 */

2471
          {

2472
            _ssSetOutputPortNumDimensions(childS, 0, 1);

2473
            ssSetOutputPortWidth(childS, 0, 1);

2474
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

2475
              ssGetLocalBlockIO(rts))->GeneratedSFunction_g));

2476
          }

2477
        }

2478


2479
        /* path info */

2480
        _ssSetModelName(childS, "SaturationLimiter_sf");

2481
        _ssSetPath(childS,

2482
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Saturation Limiter1/Generated S-Function");

2483
        if (ssGetRTModel(rts) == (NULL)) {

2484
          _ssSetParentSS(childS, rts);

2485
          _ssSetRootSS(childS, ssGetRootSS(rts));

2486
        } else {

2487
          ssSetRTModel(childS,ssGetRTModel(rts));

2488
          _ssSetParentSS(childS, (NULL));

2489
          _ssSetRootSS(childS, childS);

2490
        }

2491


2492
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

2493
        (childS)->regDataType.arg1 = ((void *)(childS));

2494
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

2495
          FcnSetErrorStatus);

2496
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

2497
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

2498
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

2499
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

2500


2501
        /* registration */

2502
#if defined(MATLAB_MEX_FILE)

2503


2504
        {

2505
          int_T i;

2506
          mxArray *plhs[1];

2507
          mxArray *prhs[4];

2508
          double *pr;

2509
          volatile int_T *intS = (int_T *)&childS;

2510
          int_T addrlen = sizeof(SimStruct *);

2511
          int_T m = addrlen/sizeof(int_T) + 1;

2512
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

2513
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

2514
          pr = mxGetPr(prhs[1]);

2515
          for (i = 0; i < m - 1; i++) {

2516
            pr[i] = (double)intS[i];

2517
          }

2518


2519
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

2520
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

2521
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

2522


2523
          /* Reset port dimensions info functions because the S-function

2524
           * and accelerator mex-files explicitly set their dimensions,

2525
           * i.e., they are not dynamically sized. For this case, the

2526
           * mex-file is responsible for the dimensions info memory

2527
           * and Simulink should not free it. This is achieved by

2528
           * setting the following two methods to NULL.

2529
           */

2530
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

2531
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

2532


2533
          /*

2534
           * Setup function pointers and call mdlInitializeSizes via

2535
           * simulink.c

2536
           */

2537
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

2538
          mxDestroyArray(plhs[0]);

2539
          mxDestroyArray(prhs[0]);

2540
          mxDestroyArray(prhs[1]);

2541
          mxDestroyArray(prhs[2]);

2542
          mxDestroyArray(prhs[3]);

2543
        }

2544


2545
#else

2546


2547
        {

2548
          SaturationLimiter_sf(childS);

2549
          sfcnInitializeSizes(childS);

2550
        }

2551


2552
#endif

2553


2554
        sfcnInitializeSampleTimes(childS);

2555


2556
        /* adjust sample time */

2557
        ssSetSampleTime(childS, 0, 0.0);

2558
        ssSetOffsetTime(childS, 0, 0.0);

2559
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

2560


2561
        /* set compiled values of dynamic vector attributes */

2562
        ssSetNumNonsampledZCs(childS, 0);

2563


2564
        /* Update connectivity flags for each port */

2565
        _ssSetInputPortConnected(childS, 0, 1);

2566
        _ssSetInputPortConnected(childS, 1, 1);

2567
        _ssSetInputPortConnected(childS, 2, 1);

2568
        _ssSetOutputPortConnected(childS, 0, 1);

2569
        _ssSetOutputPortBeingMerged(childS, 0, 0);

2570


2571
        /* Update the BufferDstPort flags for each input port */

2572
        _ssSetInputPortBufferDstPort(childS, 0, -1);

2573
        _ssSetInputPortBufferDstPort(childS, 1, -1);

2574
        _ssSetInputPortBufferDstPort(childS, 2, -1);

2575
      }

2576


2577
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S181>/Generated S-Function (Gain_sf) */

2578
      {

2579
        SimStruct *childS = ssGetSFunction(rts, 9);

2580


2581
        /* timing info */

2582
        time_T *sfcnPeriod;

2583
        time_T *sfcnOffset;

2584
        int_T *sfcnTsMap;

2585
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

2586
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

2587
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

2588
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

2589
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

2590
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

2591
        (void) memset((void*)sfcnPeriod, 0,

2592
                      sizeof(time_T)*1);

2593
        (void) memset((void*)sfcnOffset, 0,

2594
                      sizeof(time_T)*1);

2595
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

2596
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

2597
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

2598


2599
        /* Set up the mdlInfo pointer */

2600
# ifdef USE_RTMODEL

2601


2602
        {

2603
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

2604
              struct _ssBlkInfo2));

2605
          ss_VALIDATE_MEMORY(rts,blkInfo2);

2606
          ssSetBlkInfo2Ptr(childS, blkInfo2);

2607
        }

2608


2609
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

2610


2611
# else

2612


2613
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

2614


2615
# endif                                /* USE_RTMODEL */

2616


2617
        /* Allocate memory of model methods 2 */

2618
        {

2619
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

2620
            malloc(sizeof(struct _ssSFcnModelMethods2));

2621
          ss_VALIDATE_MEMORY(rts,methods2);

2622
          ssSetModelMethods2(childS, methods2);

2623
        }

2624


2625
        /* Allocate memory of model methods 3 */

2626
        {

2627
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

2628
            malloc(sizeof(struct _ssSFcnModelMethods3));

2629
          ss_VALIDATE_MEMORY(rts,methods3);

2630
          ssSetModelMethods3(childS, methods3);

2631
        }

2632


2633
        /* Allocate memory for states auxilliary information */

2634
        {

2635
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

2636
            (sizeof(struct _ssStatesInfo2));

2637
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

2638
            malloc(sizeof(ssPeriodicStatesInfo));

2639
          ss_VALIDATE_MEMORY(rts,statesInfo2);

2640
          ssSetStatesInfo2(childS, statesInfo2);

2641
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

2642
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

2643
        }

2644


2645
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

2646
          RegNumInputPorts);

2647
        ssSetRegNumInputPortsFcnArg(childS,childS);

2648


2649
        /* inputs */

2650
        {

2651
          struct _ssPortInputs *inputPortInfo =

2652
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

2653
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

2654
          _ssSetNumInputPorts(childS, 2);

2655
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

2656


2657
          /* port 0 */

2658
          {

2659
            real32_T const **sfcnUPtrs = (real32_T const **)

2660
              malloc(1 * sizeof(real32_T *));

2661
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2662
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2663
              ssGetLocalBlockIO(rts))->GeneratedSFunction_g;

2664
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

2665
            _ssSetInputPortNumDimensions(childS, 0, 1);

2666
            ssSetInputPortWidth(childS, 0, 1);

2667
          }

2668


2669
          /* port 1 */

2670
          {

2671
            real32_T const **sfcnUPtrs = (real32_T const **)

2672
              malloc(1 * sizeof(real32_T *));

2673
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2674
            sfcnUPtrs[0] = (real32_T const *)

2675
              &AFCS_MODEL1_ConstP.Constant1_Value_i;

2676
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

2677
            _ssSetInputPortNumDimensions(childS, 1, 1);

2678
            ssSetInputPortWidth(childS, 1, 1);

2679
          }

2680
        }

2681


2682
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

2683
          RegNumOutputPorts);

2684
        ssSetRegNumOutputPortsFcnArg(childS,childS);

2685


2686
        /* outputs */

2687
        {

2688
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

2689
            calloc(1, sizeof(struct _ssPortOutputs));

2690
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

2691
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

2692
          _ssSetNumOutputPorts(childS, 1);

2693


2694
          /* port 0 */

2695
          {

2696
            _ssSetOutputPortNumDimensions(childS, 0, 1);

2697
            ssSetOutputPortWidth(childS, 0, 1);

2698
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

2699
              ssGetLocalBlockIO(rts))->GeneratedSFunction_j5));

2700
          }

2701
        }

2702


2703
        /* path info */

2704
        _ssSetModelName(childS, "Gain_sf");

2705
        _ssSetPath(childS,

2706
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/gain/Generated S-Function");

2707
        if (ssGetRTModel(rts) == (NULL)) {

2708
          _ssSetParentSS(childS, rts);

2709
          _ssSetRootSS(childS, ssGetRootSS(rts));

2710
        } else {

2711
          ssSetRTModel(childS,ssGetRTModel(rts));

2712
          _ssSetParentSS(childS, (NULL));

2713
          _ssSetRootSS(childS, childS);

2714
        }

2715


2716
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

2717
        (childS)->regDataType.arg1 = ((void *)(childS));

2718
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

2719
          FcnSetErrorStatus);

2720
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

2721
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

2722
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

2723
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

2724


2725
        /* registration */

2726
#if defined(MATLAB_MEX_FILE)

2727


2728
        {

2729
          int_T i;

2730
          mxArray *plhs[1];

2731
          mxArray *prhs[4];

2732
          double *pr;

2733
          volatile int_T *intS = (int_T *)&childS;

2734
          int_T addrlen = sizeof(SimStruct *);

2735
          int_T m = addrlen/sizeof(int_T) + 1;

2736
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

2737
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

2738
          pr = mxGetPr(prhs[1]);

2739
          for (i = 0; i < m - 1; i++) {

2740
            pr[i] = (double)intS[i];

2741
          }

2742


2743
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

2744
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

2745
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

2746


2747
          /* Reset port dimensions info functions because the S-function

2748
           * and accelerator mex-files explicitly set their dimensions,

2749
           * i.e., they are not dynamically sized. For this case, the

2750
           * mex-file is responsible for the dimensions info memory

2751
           * and Simulink should not free it. This is achieved by

2752
           * setting the following two methods to NULL.

2753
           */

2754
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

2755
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

2756


2757
          /*

2758
           * Setup function pointers and call mdlInitializeSizes via

2759
           * simulink.c

2760
           */

2761
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

2762
          mxDestroyArray(plhs[0]);

2763
          mxDestroyArray(prhs[0]);

2764
          mxDestroyArray(prhs[1]);

2765
          mxDestroyArray(prhs[2]);

2766
          mxDestroyArray(prhs[3]);

2767
        }

2768


2769
#else

2770


2771
        {

2772
          Gain_sf(childS);

2773
          sfcnInitializeSizes(childS);

2774
        }

2775


2776
#endif

2777


2778
        sfcnInitializeSampleTimes(childS);

2779


2780
        /* adjust sample time */

2781
        ssSetSampleTime(childS, 0, 0.0);

2782
        ssSetOffsetTime(childS, 0, 0.0);

2783
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

2784


2785
        /* set compiled values of dynamic vector attributes */

2786
        ssSetNumNonsampledZCs(childS, 0);

2787


2788
        /* Update connectivity flags for each port */

2789
        _ssSetInputPortConnected(childS, 0, 1);

2790
        _ssSetInputPortConnected(childS, 1, 1);

2791
        _ssSetOutputPortConnected(childS, 0, 1);

2792
        _ssSetOutputPortBeingMerged(childS, 0, 0);

2793


2794
        /* Update the BufferDstPort flags for each input port */

2795
        _ssSetInputPortBufferDstPort(childS, 0, -1);

2796
        _ssSetInputPortBufferDstPort(childS, 1, -1);

2797
      }

2798


2799
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S178>/Generated S-Function (LeadLagFilter_sf) */

2800
      {

2801
        SimStruct *childS = ssGetSFunction(rts, 10);

2802


2803
        /* timing info */

2804
        time_T *sfcnPeriod;

2805
        time_T *sfcnOffset;

2806
        int_T *sfcnTsMap;

2807
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

2808
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

2809
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

2810
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

2811
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

2812
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

2813
        (void) memset((void*)sfcnPeriod, 0,

2814
                      sizeof(time_T)*1);

2815
        (void) memset((void*)sfcnOffset, 0,

2816
                      sizeof(time_T)*1);

2817
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

2818
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

2819
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

2820


2821
        /* Set up the mdlInfo pointer */

2822
# ifdef USE_RTMODEL

2823


2824
        {

2825
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

2826
              struct _ssBlkInfo2));

2827
          ss_VALIDATE_MEMORY(rts,blkInfo2);

2828
          ssSetBlkInfo2Ptr(childS, blkInfo2);

2829
        }

2830


2831
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

2832


2833
# else

2834


2835
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

2836


2837
# endif                                /* USE_RTMODEL */

2838


2839
        /* Allocate memory of model methods 2 */

2840
        {

2841
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

2842
            malloc(sizeof(struct _ssSFcnModelMethods2));

2843
          ss_VALIDATE_MEMORY(rts,methods2);

2844
          ssSetModelMethods2(childS, methods2);

2845
        }

2846


2847
        /* Allocate memory of model methods 3 */

2848
        {

2849
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

2850
            malloc(sizeof(struct _ssSFcnModelMethods3));

2851
          ss_VALIDATE_MEMORY(rts,methods3);

2852
          ssSetModelMethods3(childS, methods3);

2853
        }

2854


2855
        /* Allocate memory for states auxilliary information */

2856
        {

2857
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

2858
            (sizeof(struct _ssStatesInfo2));

2859
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

2860
            malloc(sizeof(ssPeriodicStatesInfo));

2861
          ss_VALIDATE_MEMORY(rts,statesInfo2);

2862
          ssSetStatesInfo2(childS, statesInfo2);

2863
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

2864
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

2865
        }

2866


2867
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

2868
          RegNumInputPorts);

2869
        ssSetRegNumInputPortsFcnArg(childS,childS);

2870


2871
        /* inputs */

2872
        {

2873
          struct _ssPortInputs *inputPortInfo =

2874
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

2875
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

2876
          _ssSetNumInputPorts(childS, 7);

2877
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

2878


2879
          /* port 0 */

2880
          {

2881
            real32_T const **sfcnUPtrs = (real32_T const **)

2882
              malloc(1 * sizeof(real32_T *));

2883
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2884
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2885
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

2886
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

2887
            _ssSetInputPortNumDimensions(childS, 0, 1);

2888
            ssSetInputPortWidth(childS, 0, 1);

2889
          }

2890


2891
          /* port 1 */

2892
          {

2893
            int8_T const **sfcnUPtrs = (int8_T const **)

2894
              malloc(1 * sizeof(int8_T *));

2895
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2896
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

2897
              ssGetLocalBlockIO(rts))->DataTypeConversion2_lt;

2898
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

2899
            _ssSetInputPortNumDimensions(childS, 1, 1);

2900
            ssSetInputPortWidth(childS, 1, 1);

2901
          }

2902


2903
          /* port 2 */

2904
          {

2905
            real32_T const **sfcnUPtrs = (real32_T const **)

2906
              malloc(1 * sizeof(real32_T *));

2907
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2908
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

2909
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

2910
            _ssSetInputPortNumDimensions(childS, 2, 1);

2911
            ssSetInputPortWidth(childS, 2, 1);

2912
          }

2913


2914
          /* port 3 */

2915
          {

2916
            real32_T const **sfcnUPtrs = (real32_T const **)

2917
              malloc(1 * sizeof(real32_T *));

2918
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2919
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

2920
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

2921
            _ssSetInputPortNumDimensions(childS, 3, 1);

2922
            ssSetInputPortWidth(childS, 3, 1);

2923
          }

2924


2925
          /* port 4 */

2926
          {

2927
            real32_T const **sfcnUPtrs = (real32_T const **)

2928
              malloc(1 * sizeof(real32_T *));

2929
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2930
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2931
              ssGetLocalBlockIO(rts))->Switch_k;

2932
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

2933
            _ssSetInputPortNumDimensions(childS, 4, 1);

2934
            ssSetInputPortWidth(childS, 4, 1);

2935
          }

2936


2937
          /* port 5 */

2938
          {

2939
            real32_T const **sfcnUPtrs = (real32_T const **)

2940
              malloc(1 * sizeof(real32_T *));

2941
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2942
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2943
              ssGetLocalBlockIO(rts))->Switch_k;

2944
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

2945
            _ssSetInputPortNumDimensions(childS, 5, 1);

2946
            ssSetInputPortWidth(childS, 5, 1);

2947
          }

2948


2949
          /* port 6 */

2950
          {

2951
            real32_T const **sfcnUPtrs = (real32_T const **)

2952
              malloc(1 * sizeof(real32_T *));

2953
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

2954
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

2955
              ssGetLocalBlockIO(rts))->GeneratedSFunction_j5;

2956
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

2957
            _ssSetInputPortNumDimensions(childS, 6, 1);

2958
            ssSetInputPortWidth(childS, 6, 1);

2959
          }

2960
        }

2961


2962
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

2963
          RegNumOutputPorts);

2964
        ssSetRegNumOutputPortsFcnArg(childS,childS);

2965


2966
        /* outputs */

2967
        {

2968
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

2969
            calloc(1, sizeof(struct _ssPortOutputs));

2970
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

2971
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

2972
          _ssSetNumOutputPorts(childS, 1);

2973


2974
          /* port 0 */

2975
          {

2976
            _ssSetOutputPortNumDimensions(childS, 0, 1);

2977
            ssSetOutputPortWidth(childS, 0, 1);

2978
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

2979
              ssGetLocalBlockIO(rts))->GeneratedSFunction_e));

2980
          }

2981
        }

2982


2983
        /* path info */

2984
        _ssSetModelName(childS, "LeadLagFilter_sf");

2985
        _ssSetPath(childS,

2986
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Lead lag/Generated S-Function");

2987
        if (ssGetRTModel(rts) == (NULL)) {

2988
          _ssSetParentSS(childS, rts);

2989
          _ssSetRootSS(childS, ssGetRootSS(rts));

2990
        } else {

2991
          ssSetRTModel(childS,ssGetRTModel(rts));

2992
          _ssSetParentSS(childS, (NULL));

2993
          _ssSetRootSS(childS, childS);

2994
        }

2995


2996
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

2997


2998
        /* work vectors */

2999
        {

3000
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

3001
            (4 * sizeof(struct _ssDWorkRecord));

3002
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

3003
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

3004
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

3005
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

3006
          ssSetSFcnDWork(childS, dWorkRecord);

3007
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

3008
          _ssSetNumDWork(childS, 4);

3009


3010
          /* DWORK0 */

3011
          ssSetDWorkWidth(childS, 0, 1);

3012
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

3013
          ssSetDWorkComplexSignal(childS, 0, 0);

3014
          ssSetDWorkUsedAsDState(childS, 0, 1);

3015
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 155))[0]);

3016


3017
          /* DWORK1 */

3018
          ssSetDWorkWidth(childS, 1, 1);

3019
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

3020
          ssSetDWorkComplexSignal(childS, 1, 0);

3021
          ssSetDWorkUsedAsDState(childS, 1, 1);

3022
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 156))[0]);

3023


3024
          /* DWORK2 */

3025
          ssSetDWorkWidth(childS, 2, 1);

3026
          ssSetDWorkDataType(childS, 2,SS_INT8);

3027
          ssSetDWorkComplexSignal(childS, 2, 0);

3028
          ssSetDWorkUsedAsDState(childS, 2, 1);

3029
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 382))[0]);

3030


3031
          /* DWORK3 */

3032
          ssSetDWorkWidth(childS, 3, 1);

3033
          ssSetDWorkDataType(childS, 3,SS_INT8);

3034
          ssSetDWorkComplexSignal(childS, 3, 0);

3035
          ssSetDWorkUsedAsDState(childS, 3, 1);

3036
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 383))[0]);

3037
        }

3038


3039
        (childS)->regDataType.arg1 = ((void *)(childS));

3040
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

3041
          FcnSetErrorStatus);

3042
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

3043
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

3044
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

3045
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

3046


3047
        /* registration */

3048
#if defined(MATLAB_MEX_FILE)

3049


3050
        {

3051
          int_T i;

3052
          mxArray *plhs[1];

3053
          mxArray *prhs[4];

3054
          double *pr;

3055
          volatile int_T *intS = (int_T *)&childS;

3056
          int_T addrlen = sizeof(SimStruct *);

3057
          int_T m = addrlen/sizeof(int_T) + 1;

3058
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

3059
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

3060
          pr = mxGetPr(prhs[1]);

3061
          for (i = 0; i < m - 1; i++) {

3062
            pr[i] = (double)intS[i];

3063
          }

3064


3065
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

3066
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

3067
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

3068


3069
          /* Reset port dimensions info functions because the S-function

3070
           * and accelerator mex-files explicitly set their dimensions,

3071
           * i.e., they are not dynamically sized. For this case, the

3072
           * mex-file is responsible for the dimensions info memory

3073
           * and Simulink should not free it. This is achieved by

3074
           * setting the following two methods to NULL.

3075
           */

3076
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

3077
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

3078


3079
          /*

3080
           * Setup function pointers and call mdlInitializeSizes via

3081
           * simulink.c

3082
           */

3083
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

3084
          mxDestroyArray(plhs[0]);

3085
          mxDestroyArray(prhs[0]);

3086
          mxDestroyArray(prhs[1]);

3087
          mxDestroyArray(prhs[2]);

3088
          mxDestroyArray(prhs[3]);

3089
        }

3090


3091
#else

3092


3093
        {

3094
          LeadLagFilter_sf(childS);

3095
          sfcnInitializeSizes(childS);

3096
        }

3097


3098
#endif

3099


3100
        sfcnInitializeSampleTimes(childS);

3101


3102
        /* adjust sample time */

3103
        ssSetSampleTime(childS, 0, 0.0);

3104
        ssSetOffsetTime(childS, 0, 0.0);

3105
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

3106


3107
        /* set compiled values of dynamic vector attributes */

3108
        ssSetNumNonsampledZCs(childS, 0);

3109


3110
        /* Update connectivity flags for each port */

3111
        _ssSetInputPortConnected(childS, 0, 1);

3112
        _ssSetInputPortConnected(childS, 1, 1);

3113
        _ssSetInputPortConnected(childS, 2, 1);

3114
        _ssSetInputPortConnected(childS, 3, 1);

3115
        _ssSetInputPortConnected(childS, 4, 1);

3116
        _ssSetInputPortConnected(childS, 5, 1);

3117
        _ssSetInputPortConnected(childS, 6, 1);

3118
        _ssSetOutputPortConnected(childS, 0, 1);

3119
        _ssSetOutputPortBeingMerged(childS, 0, 0);

3120


3121
        /* Update the BufferDstPort flags for each input port */

3122
        _ssSetInputPortBufferDstPort(childS, 0, -1);

3123
        _ssSetInputPortBufferDstPort(childS, 1, -1);

3124
        _ssSetInputPortBufferDstPort(childS, 2, -1);

3125
        _ssSetInputPortBufferDstPort(childS, 3, -1);

3126
        _ssSetInputPortBufferDstPort(childS, 4, -1);

3127
        _ssSetInputPortBufferDstPort(childS, 5, -1);

3128
        _ssSetInputPortBufferDstPort(childS, 6, -1);

3129
      }

3130


3131
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S180>/Generated S-Function (SaturationLimiter_sf) */

3132
      {

3133
        SimStruct *childS = ssGetSFunction(rts, 11);

3134


3135
        /* timing info */

3136
        time_T *sfcnPeriod;

3137
        time_T *sfcnOffset;

3138
        int_T *sfcnTsMap;

3139
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

3140
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

3141
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

3142
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

3143
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

3144
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

3145
        (void) memset((void*)sfcnPeriod, 0,

3146
                      sizeof(time_T)*1);

3147
        (void) memset((void*)sfcnOffset, 0,

3148
                      sizeof(time_T)*1);

3149
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

3150
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

3151
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

3152


3153
        /* Set up the mdlInfo pointer */

3154
# ifdef USE_RTMODEL

3155


3156
        {

3157
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

3158
              struct _ssBlkInfo2));

3159
          ss_VALIDATE_MEMORY(rts,blkInfo2);

3160
          ssSetBlkInfo2Ptr(childS, blkInfo2);

3161
        }

3162


3163
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

3164


3165
# else

3166


3167
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

3168


3169
# endif                                /* USE_RTMODEL */

3170


3171
        /* Allocate memory of model methods 2 */

3172
        {

3173
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

3174
            malloc(sizeof(struct _ssSFcnModelMethods2));

3175
          ss_VALIDATE_MEMORY(rts,methods2);

3176
          ssSetModelMethods2(childS, methods2);

3177
        }

3178


3179
        /* Allocate memory of model methods 3 */

3180
        {

3181
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

3182
            malloc(sizeof(struct _ssSFcnModelMethods3));

3183
          ss_VALIDATE_MEMORY(rts,methods3);

3184
          ssSetModelMethods3(childS, methods3);

3185
        }

3186


3187
        /* Allocate memory for states auxilliary information */

3188
        {

3189
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

3190
            (sizeof(struct _ssStatesInfo2));

3191
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

3192
            malloc(sizeof(ssPeriodicStatesInfo));

3193
          ss_VALIDATE_MEMORY(rts,statesInfo2);

3194
          ssSetStatesInfo2(childS, statesInfo2);

3195
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

3196
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

3197
        }

3198


3199
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

3200
          RegNumInputPorts);

3201
        ssSetRegNumInputPortsFcnArg(childS,childS);

3202


3203
        /* inputs */

3204
        {

3205
          struct _ssPortInputs *inputPortInfo =

3206
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

3207
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

3208
          _ssSetNumInputPorts(childS, 3);

3209
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

3210


3211
          /* port 0 */

3212
          {

3213
            real32_T const **sfcnUPtrs = (real32_T const **)

3214
              malloc(1 * sizeof(real32_T *));

3215
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3216
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3217
              ssGetLocalBlockIO(rts))->GeneratedSFunction_e;

3218
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

3219
            _ssSetInputPortNumDimensions(childS, 0, 1);

3220
            ssSetInputPortWidth(childS, 0, 1);

3221
          }

3222


3223
          /* port 1 */

3224
          {

3225
            real32_T const **sfcnUPtrs = (real32_T const **)

3226
              malloc(1 * sizeof(real32_T *));

3227
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3228
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

3229
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

3230
            _ssSetInputPortNumDimensions(childS, 1, 1);

3231
            ssSetInputPortWidth(childS, 1, 1);

3232
          }

3233


3234
          /* port 2 */

3235
          {

3236
            real32_T const **sfcnUPtrs = (real32_T const **)

3237
              malloc(1 * sizeof(real32_T *));

3238
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3239
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled110;

3240
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

3241
            _ssSetInputPortNumDimensions(childS, 2, 1);

3242
            ssSetInputPortWidth(childS, 2, 1);

3243
          }

3244
        }

3245


3246
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

3247
          RegNumOutputPorts);

3248
        ssSetRegNumOutputPortsFcnArg(childS,childS);

3249


3250
        /* outputs */

3251
        {

3252
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

3253
            calloc(1, sizeof(struct _ssPortOutputs));

3254
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

3255
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

3256
          _ssSetNumOutputPorts(childS, 1);

3257


3258
          /* port 0 */

3259
          {

3260
            _ssSetOutputPortNumDimensions(childS, 0, 1);

3261
            ssSetOutputPortWidth(childS, 0, 1);

3262
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

3263
              ssGetLocalBlockIO(rts))->Product1_g));

3264
          }

3265
        }

3266


3267
        /* path info */

3268
        _ssSetModelName(childS, "SaturationLimiter_sf");

3269
        _ssSetPath(childS,

3270
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Saturation Limiter3/Generated S-Function");

3271
        if (ssGetRTModel(rts) == (NULL)) {

3272
          _ssSetParentSS(childS, rts);

3273
          _ssSetRootSS(childS, ssGetRootSS(rts));

3274
        } else {

3275
          ssSetRTModel(childS,ssGetRTModel(rts));

3276
          _ssSetParentSS(childS, (NULL));

3277
          _ssSetRootSS(childS, childS);

3278
        }

3279


3280
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

3281
        (childS)->regDataType.arg1 = ((void *)(childS));

3282
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

3283
          FcnSetErrorStatus);

3284
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

3285
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

3286
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

3287
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

3288


3289
        /* registration */

3290
#if defined(MATLAB_MEX_FILE)

3291


3292
        {

3293
          int_T i;

3294
          mxArray *plhs[1];

3295
          mxArray *prhs[4];

3296
          double *pr;

3297
          volatile int_T *intS = (int_T *)&childS;

3298
          int_T addrlen = sizeof(SimStruct *);

3299
          int_T m = addrlen/sizeof(int_T) + 1;

3300
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

3301
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

3302
          pr = mxGetPr(prhs[1]);

3303
          for (i = 0; i < m - 1; i++) {

3304
            pr[i] = (double)intS[i];

3305
          }

3306


3307
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

3308
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

3309
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

3310


3311
          /* Reset port dimensions info functions because the S-function

3312
           * and accelerator mex-files explicitly set their dimensions,

3313
           * i.e., they are not dynamically sized. For this case, the

3314
           * mex-file is responsible for the dimensions info memory

3315
           * and Simulink should not free it. This is achieved by

3316
           * setting the following two methods to NULL.

3317
           */

3318
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

3319
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

3320


3321
          /*

3322
           * Setup function pointers and call mdlInitializeSizes via

3323
           * simulink.c

3324
           */

3325
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

3326
          mxDestroyArray(plhs[0]);

3327
          mxDestroyArray(prhs[0]);

3328
          mxDestroyArray(prhs[1]);

3329
          mxDestroyArray(prhs[2]);

3330
          mxDestroyArray(prhs[3]);

3331
        }

3332


3333
#else

3334


3335
        {

3336
          SaturationLimiter_sf(childS);

3337
          sfcnInitializeSizes(childS);

3338
        }

3339


3340
#endif

3341


3342
        sfcnInitializeSampleTimes(childS);

3343


3344
        /* adjust sample time */

3345
        ssSetSampleTime(childS, 0, 0.0);

3346
        ssSetOffsetTime(childS, 0, 0.0);

3347
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

3348


3349
        /* set compiled values of dynamic vector attributes */

3350
        ssSetNumNonsampledZCs(childS, 0);

3351


3352
        /* Update connectivity flags for each port */

3353
        _ssSetInputPortConnected(childS, 0, 1);

3354
        _ssSetInputPortConnected(childS, 1, 1);

3355
        _ssSetInputPortConnected(childS, 2, 1);

3356
        _ssSetOutputPortConnected(childS, 0, 1);

3357
        _ssSetOutputPortBeingMerged(childS, 0, 0);

3358


3359
        /* Update the BufferDstPort flags for each input port */

3360
        _ssSetInputPortBufferDstPort(childS, 0, -1);

3361
        _ssSetInputPortBufferDstPort(childS, 1, -1);

3362
        _ssSetInputPortBufferDstPort(childS, 2, -1);

3363
      }

3364


3365
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S182>/Generated S-Function (Gain_sf) */

3366
      {

3367
        SimStruct *childS = ssGetSFunction(rts, 12);

3368


3369
        /* timing info */

3370
        time_T *sfcnPeriod;

3371
        time_T *sfcnOffset;

3372
        int_T *sfcnTsMap;

3373
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

3374
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

3375
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

3376
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

3377
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

3378
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

3379
        (void) memset((void*)sfcnPeriod, 0,

3380
                      sizeof(time_T)*1);

3381
        (void) memset((void*)sfcnOffset, 0,

3382
                      sizeof(time_T)*1);

3383
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

3384
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

3385
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

3386


3387
        /* Set up the mdlInfo pointer */

3388
# ifdef USE_RTMODEL

3389


3390
        {

3391
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

3392
              struct _ssBlkInfo2));

3393
          ss_VALIDATE_MEMORY(rts,blkInfo2);

3394
          ssSetBlkInfo2Ptr(childS, blkInfo2);

3395
        }

3396


3397
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

3398


3399
# else

3400


3401
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

3402


3403
# endif                                /* USE_RTMODEL */

3404


3405
        /* Allocate memory of model methods 2 */

3406
        {

3407
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

3408
            malloc(sizeof(struct _ssSFcnModelMethods2));

3409
          ss_VALIDATE_MEMORY(rts,methods2);

3410
          ssSetModelMethods2(childS, methods2);

3411
        }

3412


3413
        /* Allocate memory of model methods 3 */

3414
        {

3415
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

3416
            malloc(sizeof(struct _ssSFcnModelMethods3));

3417
          ss_VALIDATE_MEMORY(rts,methods3);

3418
          ssSetModelMethods3(childS, methods3);

3419
        }

3420


3421
        /* Allocate memory for states auxilliary information */

3422
        {

3423
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

3424
            (sizeof(struct _ssStatesInfo2));

3425
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

3426
            malloc(sizeof(ssPeriodicStatesInfo));

3427
          ss_VALIDATE_MEMORY(rts,statesInfo2);

3428
          ssSetStatesInfo2(childS, statesInfo2);

3429
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

3430
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

3431
        }

3432


3433
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

3434
          RegNumInputPorts);

3435
        ssSetRegNumInputPortsFcnArg(childS,childS);

3436


3437
        /* inputs */

3438
        {

3439
          struct _ssPortInputs *inputPortInfo =

3440
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

3441
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

3442
          _ssSetNumInputPorts(childS, 2);

3443
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

3444


3445
          /* port 0 */

3446
          {

3447
            real32_T const **sfcnUPtrs = (real32_T const **)

3448
              malloc(1 * sizeof(real32_T *));

3449
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3450
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3451
              ssGetLocalBlockIO(rts))->GeneratedSFunction_e;

3452
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

3453
            _ssSetInputPortNumDimensions(childS, 0, 1);

3454
            ssSetInputPortWidth(childS, 0, 1);

3455
          }

3456


3457
          /* port 1 */

3458
          {

3459
            real32_T const **sfcnUPtrs = (real32_T const **)

3460
              malloc(1 * sizeof(real32_T *));

3461
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3462
            sfcnUPtrs[0] = (real32_T const *)

3463
              &AFCS_MODEL1_ConstP.Constant2_Value_c;

3464
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

3465
            _ssSetInputPortNumDimensions(childS, 1, 1);

3466
            ssSetInputPortWidth(childS, 1, 1);

3467
          }

3468
        }

3469


3470
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

3471
          RegNumOutputPorts);

3472
        ssSetRegNumOutputPortsFcnArg(childS,childS);

3473


3474
        /* outputs */

3475
        {

3476
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

3477
            calloc(1, sizeof(struct _ssPortOutputs));

3478
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

3479
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

3480
          _ssSetNumOutputPorts(childS, 1);

3481


3482
          /* port 0 */

3483
          {

3484
            _ssSetOutputPortNumDimensions(childS, 0, 1);

3485
            ssSetOutputPortWidth(childS, 0, 1);

3486
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

3487
              ssGetLocalBlockIO(rts))->GeneratedSFunction_b));

3488
          }

3489
        }

3490


3491
        /* path info */

3492
        _ssSetModelName(childS, "Gain_sf");

3493
        _ssSetPath(childS,

3494
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/gain1/Generated S-Function");

3495
        if (ssGetRTModel(rts) == (NULL)) {

3496
          _ssSetParentSS(childS, rts);

3497
          _ssSetRootSS(childS, ssGetRootSS(rts));

3498
        } else {

3499
          ssSetRTModel(childS,ssGetRTModel(rts));

3500
          _ssSetParentSS(childS, (NULL));

3501
          _ssSetRootSS(childS, childS);

3502
        }

3503


3504
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

3505
        (childS)->regDataType.arg1 = ((void *)(childS));

3506
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

3507
          FcnSetErrorStatus);

3508
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

3509
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

3510
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

3511
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

3512


3513
        /* registration */

3514
#if defined(MATLAB_MEX_FILE)

3515


3516
        {

3517
          int_T i;

3518
          mxArray *plhs[1];

3519
          mxArray *prhs[4];

3520
          double *pr;

3521
          volatile int_T *intS = (int_T *)&childS;

3522
          int_T addrlen = sizeof(SimStruct *);

3523
          int_T m = addrlen/sizeof(int_T) + 1;

3524
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

3525
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

3526
          pr = mxGetPr(prhs[1]);

3527
          for (i = 0; i < m - 1; i++) {

3528
            pr[i] = (double)intS[i];

3529
          }

3530


3531
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

3532
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

3533
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

3534


3535
          /* Reset port dimensions info functions because the S-function

3536
           * and accelerator mex-files explicitly set their dimensions,

3537
           * i.e., they are not dynamically sized. For this case, the

3538
           * mex-file is responsible for the dimensions info memory

3539
           * and Simulink should not free it. This is achieved by

3540
           * setting the following two methods to NULL.

3541
           */

3542
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

3543
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

3544


3545
          /*

3546
           * Setup function pointers and call mdlInitializeSizes via

3547
           * simulink.c

3548
           */

3549
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

3550
          mxDestroyArray(plhs[0]);

3551
          mxDestroyArray(prhs[0]);

3552
          mxDestroyArray(prhs[1]);

3553
          mxDestroyArray(prhs[2]);

3554
          mxDestroyArray(prhs[3]);

3555
        }

3556


3557
#else

3558


3559
        {

3560
          Gain_sf(childS);

3561
          sfcnInitializeSizes(childS);

3562
        }

3563


3564
#endif

3565


3566
        sfcnInitializeSampleTimes(childS);

3567


3568
        /* adjust sample time */

3569
        ssSetSampleTime(childS, 0, 0.0);

3570
        ssSetOffsetTime(childS, 0, 0.0);

3571
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

3572


3573
        /* set compiled values of dynamic vector attributes */

3574
        ssSetNumNonsampledZCs(childS, 0);

3575


3576
        /* Update connectivity flags for each port */

3577
        _ssSetInputPortConnected(childS, 0, 1);

3578
        _ssSetInputPortConnected(childS, 1, 1);

3579
        _ssSetOutputPortConnected(childS, 0, 1);

3580
        _ssSetOutputPortBeingMerged(childS, 0, 0);

3581


3582
        /* Update the BufferDstPort flags for each input port */

3583
        _ssSetInputPortBufferDstPort(childS, 0, -1);

3584
        _ssSetInputPortBufferDstPort(childS, 1, -1);

3585
      }

3586


3587
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S177>/Generated S-Function (IntegratorLimited_sf) */

3588
      {

3589
        SimStruct *childS = ssGetSFunction(rts, 13);

3590


3591
        /* timing info */

3592
        time_T *sfcnPeriod;

3593
        time_T *sfcnOffset;

3594
        int_T *sfcnTsMap;

3595
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

3596
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

3597
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

3598
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

3599
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

3600
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

3601
        (void) memset((void*)sfcnPeriod, 0,

3602
                      sizeof(time_T)*1);

3603
        (void) memset((void*)sfcnOffset, 0,

3604
                      sizeof(time_T)*1);

3605
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

3606
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

3607
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

3608


3609
        /* Set up the mdlInfo pointer */

3610
# ifdef USE_RTMODEL

3611


3612
        {

3613
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

3614
              struct _ssBlkInfo2));

3615
          ss_VALIDATE_MEMORY(rts,blkInfo2);

3616
          ssSetBlkInfo2Ptr(childS, blkInfo2);

3617
        }

3618


3619
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

3620


3621
# else

3622


3623
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

3624


3625
# endif                                /* USE_RTMODEL */

3626


3627
        /* Allocate memory of model methods 2 */

3628
        {

3629
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

3630
            malloc(sizeof(struct _ssSFcnModelMethods2));

3631
          ss_VALIDATE_MEMORY(rts,methods2);

3632
          ssSetModelMethods2(childS, methods2);

3633
        }

3634


3635
        /* Allocate memory of model methods 3 */

3636
        {

3637
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

3638
            malloc(sizeof(struct _ssSFcnModelMethods3));

3639
          ss_VALIDATE_MEMORY(rts,methods3);

3640
          ssSetModelMethods3(childS, methods3);

3641
        }

3642


3643
        /* Allocate memory for states auxilliary information */

3644
        {

3645
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

3646
            (sizeof(struct _ssStatesInfo2));

3647
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

3648
            malloc(sizeof(ssPeriodicStatesInfo));

3649
          ss_VALIDATE_MEMORY(rts,statesInfo2);

3650
          ssSetStatesInfo2(childS, statesInfo2);

3651
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

3652
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

3653
        }

3654


3655
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

3656
          RegNumInputPorts);

3657
        ssSetRegNumInputPortsFcnArg(childS,childS);

3658


3659
        /* inputs */

3660
        {

3661
          struct _ssPortInputs *inputPortInfo =

3662
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

3663
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

3664
          _ssSetNumInputPorts(childS, 7);

3665
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

3666


3667
          /* port 0 */

3668
          {

3669
            real32_T const **sfcnUPtrs = (real32_T const **)

3670
              malloc(1 * sizeof(real32_T *));

3671
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3672
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3673
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

3674
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

3675
            _ssSetInputPortNumDimensions(childS, 0, 1);

3676
            ssSetInputPortWidth(childS, 0, 1);

3677
          }

3678


3679
          /* port 1 */

3680
          {

3681
            int8_T const **sfcnUPtrs = (int8_T const **)

3682
              malloc(1 * sizeof(int8_T *));

3683
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3684
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

3685
              ssGetLocalBlockIO(rts))->DataTypeConversion2_lt;

3686
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

3687
            _ssSetInputPortNumDimensions(childS, 1, 1);

3688
            ssSetInputPortWidth(childS, 1, 1);

3689
          }

3690


3691
          /* port 2 */

3692
          {

3693
            real32_T const **sfcnUPtrs = (real32_T const **)

3694
              malloc(1 * sizeof(real32_T *));

3695
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3696
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3697
              ssGetLocalBlockIO(rts))->Add2_d;

3698
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

3699
            _ssSetInputPortNumDimensions(childS, 2, 1);

3700
            ssSetInputPortWidth(childS, 2, 1);

3701
          }

3702


3703
          /* port 3 */

3704
          {

3705
            real32_T const **sfcnUPtrs = (real32_T const **)

3706
              malloc(1 * sizeof(real32_T *));

3707
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3708
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3709
              ssGetLocalBlockIO(rts))->Add2_d;

3710
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

3711
            _ssSetInputPortNumDimensions(childS, 3, 1);

3712
            ssSetInputPortWidth(childS, 3, 1);

3713
          }

3714


3715
          /* port 4 */

3716
          {

3717
            real32_T const **sfcnUPtrs = (real32_T const **)

3718
              malloc(1 * sizeof(real32_T *));

3719
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3720
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3721
              ssGetLocalBlockIO(rts))->Add_l;

3722
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

3723
            _ssSetInputPortNumDimensions(childS, 4, 1);

3724
            ssSetInputPortWidth(childS, 4, 1);

3725
          }

3726


3727
          /* port 5 */

3728
          {

3729
            real32_T const **sfcnUPtrs = (real32_T const **)

3730
              malloc(1 * sizeof(real32_T *));

3731
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3732
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3733
              ssGetLocalBlockIO(rts))->Add1_g;

3734
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

3735
            _ssSetInputPortNumDimensions(childS, 5, 1);

3736
            ssSetInputPortWidth(childS, 5, 1);

3737
          }

3738


3739
          /* port 6 */

3740
          {

3741
            real32_T const **sfcnUPtrs = (real32_T const **)

3742
              malloc(1 * sizeof(real32_T *));

3743
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

3744
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

3745
              ssGetLocalBlockIO(rts))->GeneratedSFunction_b;

3746
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

3747
            _ssSetInputPortNumDimensions(childS, 6, 1);

3748
            ssSetInputPortWidth(childS, 6, 1);

3749
          }

3750
        }

3751


3752
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

3753
          RegNumOutputPorts);

3754
        ssSetRegNumOutputPortsFcnArg(childS,childS);

3755


3756
        /* outputs */

3757
        {

3758
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

3759
            calloc(1, sizeof(struct _ssPortOutputs));

3760
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

3761
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

3762
          _ssSetNumOutputPorts(childS, 1);

3763


3764
          /* port 0 */

3765
          {

3766
            _ssSetOutputPortNumDimensions(childS, 0, 1);

3767
            ssSetOutputPortWidth(childS, 0, 1);

3768
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

3769
              ssGetLocalBlockIO(rts))->Product1_g));

3770
          }

3771
        }

3772


3773
        /* path info */

3774
        _ssSetModelName(childS, "IntegratorLimited_sf");

3775
        _ssSetPath(childS,

3776
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Integrator Limited/Generated S-Function");

3777
        if (ssGetRTModel(rts) == (NULL)) {

3778
          _ssSetParentSS(childS, rts);

3779
          _ssSetRootSS(childS, ssGetRootSS(rts));

3780
        } else {

3781
          ssSetRTModel(childS,ssGetRTModel(rts));

3782
          _ssSetParentSS(childS, (NULL));

3783
          _ssSetRootSS(childS, childS);

3784
        }

3785


3786
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

3787


3788
        /* work vectors */

3789
        {

3790
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

3791
            (4 * sizeof(struct _ssDWorkRecord));

3792
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

3793
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

3794
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

3795
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

3796
          ssSetSFcnDWork(childS, dWorkRecord);

3797
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

3798
          _ssSetNumDWork(childS, 4);

3799


3800
          /* DWORK0 */

3801
          ssSetDWorkWidth(childS, 0, 1);

3802
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

3803
          ssSetDWorkComplexSignal(childS, 0, 0);

3804
          ssSetDWorkUsedAsDState(childS, 0, 1);

3805
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 157))[0]);

3806


3807
          /* DWORK1 */

3808
          ssSetDWorkWidth(childS, 1, 1);

3809
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

3810
          ssSetDWorkComplexSignal(childS, 1, 0);

3811
          ssSetDWorkUsedAsDState(childS, 1, 1);

3812
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 158))[0]);

3813


3814
          /* DWORK2 */

3815
          ssSetDWorkWidth(childS, 2, 1);

3816
          ssSetDWorkDataType(childS, 2,SS_INT8);

3817
          ssSetDWorkComplexSignal(childS, 2, 0);

3818
          ssSetDWorkUsedAsDState(childS, 2, 1);

3819
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 384))[0]);

3820


3821
          /* DWORK3 */

3822
          ssSetDWorkWidth(childS, 3, 1);

3823
          ssSetDWorkDataType(childS, 3,SS_INT8);

3824
          ssSetDWorkComplexSignal(childS, 3, 0);

3825
          ssSetDWorkUsedAsDState(childS, 3, 1);

3826
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 385))[0]);

3827
        }

3828


3829
        (childS)->regDataType.arg1 = ((void *)(childS));

3830
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

3831
          FcnSetErrorStatus);

3832
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

3833
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

3834
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

3835
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

3836


3837
        /* registration */

3838
#if defined(MATLAB_MEX_FILE)

3839


3840
        {

3841
          int_T i;

3842
          mxArray *plhs[1];

3843
          mxArray *prhs[4];

3844
          double *pr;

3845
          volatile int_T *intS = (int_T *)&childS;

3846
          int_T addrlen = sizeof(SimStruct *);

3847
          int_T m = addrlen/sizeof(int_T) + 1;

3848
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

3849
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

3850
          pr = mxGetPr(prhs[1]);

3851
          for (i = 0; i < m - 1; i++) {

3852
            pr[i] = (double)intS[i];

3853
          }

3854


3855
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

3856
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

3857
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

3858


3859
          /* Reset port dimensions info functions because the S-function

3860
           * and accelerator mex-files explicitly set their dimensions,

3861
           * i.e., they are not dynamically sized. For this case, the

3862
           * mex-file is responsible for the dimensions info memory

3863
           * and Simulink should not free it. This is achieved by

3864
           * setting the following two methods to NULL.

3865
           */

3866
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

3867
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

3868


3869
          /*

3870
           * Setup function pointers and call mdlInitializeSizes via

3871
           * simulink.c

3872
           */

3873
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

3874
          mxDestroyArray(plhs[0]);

3875
          mxDestroyArray(prhs[0]);

3876
          mxDestroyArray(prhs[1]);

3877
          mxDestroyArray(prhs[2]);

3878
          mxDestroyArray(prhs[3]);

3879
        }

3880


3881
#else

3882


3883
        {

3884
          IntegratorLimited_sf(childS);

3885
          sfcnInitializeSizes(childS);

3886
        }

3887


3888
#endif

3889


3890
        sfcnInitializeSampleTimes(childS);

3891


3892
        /* adjust sample time */

3893
        ssSetSampleTime(childS, 0, 0.0);

3894
        ssSetOffsetTime(childS, 0, 0.0);

3895
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

3896


3897
        /* set compiled values of dynamic vector attributes */

3898
        ssSetNumNonsampledZCs(childS, 0);

3899


3900
        /* Update connectivity flags for each port */

3901
        _ssSetInputPortConnected(childS, 0, 1);

3902
        _ssSetInputPortConnected(childS, 1, 1);

3903
        _ssSetInputPortConnected(childS, 2, 1);

3904
        _ssSetInputPortConnected(childS, 3, 1);

3905
        _ssSetInputPortConnected(childS, 4, 1);

3906
        _ssSetInputPortConnected(childS, 5, 1);

3907
        _ssSetInputPortConnected(childS, 6, 1);

3908
        _ssSetOutputPortConnected(childS, 0, 1);

3909
        _ssSetOutputPortBeingMerged(childS, 0, 0);

3910


3911
        /* Update the BufferDstPort flags for each input port */

3912
        _ssSetInputPortBufferDstPort(childS, 0, -1);

3913
        _ssSetInputPortBufferDstPort(childS, 1, -1);

3914
        _ssSetInputPortBufferDstPort(childS, 2, -1);

3915
        _ssSetInputPortBufferDstPort(childS, 3, -1);

3916
        _ssSetInputPortBufferDstPort(childS, 4, -1);

3917
        _ssSetInputPortBufferDstPort(childS, 5, -1);

3918
        _ssSetInputPortBufferDstPort(childS, 6, -1);

3919
      }

3920


3921
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S176>/Generated S-Function (LagFilter_sf) */

3922
      {

3923
        SimStruct *childS = ssGetSFunction(rts, 14);

3924


3925
        /* timing info */

3926
        time_T *sfcnPeriod;

3927
        time_T *sfcnOffset;

3928
        int_T *sfcnTsMap;

3929
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

3930
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

3931
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

3932
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

3933
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

3934
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

3935
        (void) memset((void*)sfcnPeriod, 0,

3936
                      sizeof(time_T)*1);

3937
        (void) memset((void*)sfcnOffset, 0,

3938
                      sizeof(time_T)*1);

3939
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

3940
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

3941
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

3942


3943
        /* Set up the mdlInfo pointer */

3944
# ifdef USE_RTMODEL

3945


3946
        {

3947
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

3948
              struct _ssBlkInfo2));

3949
          ss_VALIDATE_MEMORY(rts,blkInfo2);

3950
          ssSetBlkInfo2Ptr(childS, blkInfo2);

3951
        }

3952


3953
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

3954


3955
# else

3956


3957
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

3958


3959
# endif                                /* USE_RTMODEL */

3960


3961
        /* Allocate memory of model methods 2 */

3962
        {

3963
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

3964
            malloc(sizeof(struct _ssSFcnModelMethods2));

3965
          ss_VALIDATE_MEMORY(rts,methods2);

3966
          ssSetModelMethods2(childS, methods2);

3967
        }

3968


3969
        /* Allocate memory of model methods 3 */

3970
        {

3971
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

3972
            malloc(sizeof(struct _ssSFcnModelMethods3));

3973
          ss_VALIDATE_MEMORY(rts,methods3);

3974
          ssSetModelMethods3(childS, methods3);

3975
        }

3976


3977
        /* Allocate memory for states auxilliary information */

3978
        {

3979
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

3980
            (sizeof(struct _ssStatesInfo2));

3981
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

3982
            malloc(sizeof(ssPeriodicStatesInfo));

3983
          ss_VALIDATE_MEMORY(rts,statesInfo2);

3984
          ssSetStatesInfo2(childS, statesInfo2);

3985
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

3986
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

3987
        }

3988


3989
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

3990
          RegNumInputPorts);

3991
        ssSetRegNumInputPortsFcnArg(childS,childS);

3992


3993
        /* inputs */

3994
        {

3995
          struct _ssPortInputs *inputPortInfo =

3996
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

3997
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

3998
          _ssSetNumInputPorts(childS, 6);

3999
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

4000


4001
          /* port 0 */

4002
          {

4003
            real32_T const **sfcnUPtrs = (real32_T const **)

4004
              malloc(1 * sizeof(real32_T *));

4005
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4006
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

4007
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

4008
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

4009
            _ssSetInputPortNumDimensions(childS, 0, 1);

4010
            ssSetInputPortWidth(childS, 0, 1);

4011
          }

4012


4013
          /* port 1 */

4014
          {

4015
            int8_T const **sfcnUPtrs = (int8_T const **)

4016
              malloc(1 * sizeof(int8_T *));

4017
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4018
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

4019
              ssGetLocalBlockIO(rts))->DataTypeConversion2_lt;

4020
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

4021
            _ssSetInputPortNumDimensions(childS, 1, 1);

4022
            ssSetInputPortWidth(childS, 1, 1);

4023
          }

4024


4025
          /* port 2 */

4026
          {

4027
            real32_T const **sfcnUPtrs = (real32_T const **)

4028
              malloc(1 * sizeof(real32_T *));

4029
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4030
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

4031
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

4032
            _ssSetInputPortNumDimensions(childS, 2, 1);

4033
            ssSetInputPortWidth(childS, 2, 1);

4034
          }

4035


4036
          /* port 3 */

4037
          {

4038
            real32_T const **sfcnUPtrs = (real32_T const **)

4039
              malloc(1 * sizeof(real32_T *));

4040
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4041
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

4042
              ssGetLocalBlockIO(rts))->Switch_k;

4043
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

4044
            _ssSetInputPortNumDimensions(childS, 3, 1);

4045
            ssSetInputPortWidth(childS, 3, 1);

4046
          }

4047


4048
          /* port 4 */

4049
          {

4050
            real32_T const **sfcnUPtrs = (real32_T const **)

4051
              malloc(1 * sizeof(real32_T *));

4052
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4053
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

4054
              ssGetLocalBlockIO(rts))->Switch_k;

4055
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

4056
            _ssSetInputPortNumDimensions(childS, 4, 1);

4057
            ssSetInputPortWidth(childS, 4, 1);

4058
          }

4059


4060
          /* port 5 */

4061
          {

4062
            real32_T const **sfcnUPtrs = (real32_T const **)

4063
              malloc(1 * sizeof(real32_T *));

4064
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4065
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

4066
              ssGetLocalBlockIO(rts))->Sum1_a;

4067
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

4068
            _ssSetInputPortNumDimensions(childS, 5, 1);

4069
            ssSetInputPortWidth(childS, 5, 1);

4070
          }

4071
        }

4072


4073
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

4074
          RegNumOutputPorts);

4075
        ssSetRegNumOutputPortsFcnArg(childS,childS);

4076


4077
        /* outputs */

4078
        {

4079
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

4080
            calloc(1, sizeof(struct _ssPortOutputs));

4081
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

4082
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

4083
          _ssSetNumOutputPorts(childS, 1);

4084


4085
          /* port 0 */

4086
          {

4087
            _ssSetOutputPortNumDimensions(childS, 0, 1);

4088
            ssSetOutputPortWidth(childS, 0, 1);

4089
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

4090
              ssGetLocalBlockIO(rts))->GeneratedSFunction_m));

4091
          }

4092
        }

4093


4094
        /* path info */

4095
        _ssSetModelName(childS, "LagFilter_sf");

4096
        _ssSetPath(childS,

4097
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/ lag filter/Generated S-Function");

4098
        if (ssGetRTModel(rts) == (NULL)) {

4099
          _ssSetParentSS(childS, rts);

4100
          _ssSetRootSS(childS, ssGetRootSS(rts));

4101
        } else {

4102
          ssSetRTModel(childS,ssGetRTModel(rts));

4103
          _ssSetParentSS(childS, (NULL));

4104
          _ssSetRootSS(childS, childS);

4105
        }

4106


4107
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

4108


4109
        /* work vectors */

4110
        {

4111
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

4112
            (4 * sizeof(struct _ssDWorkRecord));

4113
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

4114
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

4115
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

4116
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

4117
          ssSetSFcnDWork(childS, dWorkRecord);

4118
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

4119
          _ssSetNumDWork(childS, 4);

4120


4121
          /* DWORK0 */

4122
          ssSetDWorkWidth(childS, 0, 1);

4123
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

4124
          ssSetDWorkComplexSignal(childS, 0, 0);

4125
          ssSetDWorkUsedAsDState(childS, 0, 1);

4126
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 159))[0]);

4127


4128
          /* DWORK1 */

4129
          ssSetDWorkWidth(childS, 1, 1);

4130
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

4131
          ssSetDWorkComplexSignal(childS, 1, 0);

4132
          ssSetDWorkUsedAsDState(childS, 1, 1);

4133
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 160))[0]);

4134


4135
          /* DWORK2 */

4136
          ssSetDWorkWidth(childS, 2, 1);

4137
          ssSetDWorkDataType(childS, 2,SS_INT8);

4138
          ssSetDWorkComplexSignal(childS, 2, 0);

4139
          ssSetDWorkUsedAsDState(childS, 2, 1);

4140
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 386))[0]);

4141


4142
          /* DWORK3 */

4143
          ssSetDWorkWidth(childS, 3, 1);

4144
          ssSetDWorkDataType(childS, 3,SS_INT8);

4145
          ssSetDWorkComplexSignal(childS, 3, 0);

4146
          ssSetDWorkUsedAsDState(childS, 3, 1);

4147
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 387))[0]);

4148
        }

4149


4150
        (childS)->regDataType.arg1 = ((void *)(childS));

4151
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

4152
          FcnSetErrorStatus);

4153
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

4154
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

4155
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

4156
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

4157


4158
        /* registration */

4159
#if defined(MATLAB_MEX_FILE)

4160


4161
        {

4162
          int_T i;

4163
          mxArray *plhs[1];

4164
          mxArray *prhs[4];

4165
          double *pr;

4166
          volatile int_T *intS = (int_T *)&childS;

4167
          int_T addrlen = sizeof(SimStruct *);

4168
          int_T m = addrlen/sizeof(int_T) + 1;

4169
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

4170
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

4171
          pr = mxGetPr(prhs[1]);

4172
          for (i = 0; i < m - 1; i++) {

4173
            pr[i] = (double)intS[i];

4174
          }

4175


4176
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

4177
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

4178
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

4179


4180
          /* Reset port dimensions info functions because the S-function

4181
           * and accelerator mex-files explicitly set their dimensions,

4182
           * i.e., they are not dynamically sized. For this case, the

4183
           * mex-file is responsible for the dimensions info memory

4184
           * and Simulink should not free it. This is achieved by

4185
           * setting the following two methods to NULL.

4186
           */

4187
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

4188
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

4189


4190
          /*

4191
           * Setup function pointers and call mdlInitializeSizes via

4192
           * simulink.c

4193
           */

4194
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

4195
          mxDestroyArray(plhs[0]);

4196
          mxDestroyArray(prhs[0]);

4197
          mxDestroyArray(prhs[1]);

4198
          mxDestroyArray(prhs[2]);

4199
          mxDestroyArray(prhs[3]);

4200
        }

4201


4202
#else

4203


4204
        {

4205
          LagFilter_sf(childS);

4206
          sfcnInitializeSizes(childS);

4207
        }

4208


4209
#endif

4210


4211
        sfcnInitializeSampleTimes(childS);

4212


4213
        /* adjust sample time */

4214
        ssSetSampleTime(childS, 0, 0.0);

4215
        ssSetOffsetTime(childS, 0, 0.0);

4216
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

4217


4218
        /* set compiled values of dynamic vector attributes */

4219
        ssSetNumNonsampledZCs(childS, 0);

4220


4221
        /* Update connectivity flags for each port */

4222
        _ssSetInputPortConnected(childS, 0, 1);

4223
        _ssSetInputPortConnected(childS, 1, 1);

4224
        _ssSetInputPortConnected(childS, 2, 1);

4225
        _ssSetInputPortConnected(childS, 3, 1);

4226
        _ssSetInputPortConnected(childS, 4, 1);

4227
        _ssSetInputPortConnected(childS, 5, 1);

4228
        _ssSetOutputPortConnected(childS, 0, 1);

4229
        _ssSetOutputPortBeingMerged(childS, 0, 0);

4230


4231
        /* Update the BufferDstPort flags for each input port */

4232
        _ssSetInputPortBufferDstPort(childS, 0, -1);

4233
        _ssSetInputPortBufferDstPort(childS, 1, -1);

4234
        _ssSetInputPortBufferDstPort(childS, 2, -1);

4235
        _ssSetInputPortBufferDstPort(childS, 3, -1);

4236
        _ssSetInputPortBufferDstPort(childS, 4, -1);

4237
        _ssSetInputPortBufferDstPort(childS, 5, -1);

4238
      }

4239


4240
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S92>/Generated S-Function1 (SaturationLimiter_sf) */

4241
      {

4242
        SimStruct *childS = ssGetSFunction(rts, 15);

4243


4244
        /* timing info */

4245
        time_T *sfcnPeriod;

4246
        time_T *sfcnOffset;

4247
        int_T *sfcnTsMap;

4248
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

4249
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

4250
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

4251
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

4252
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

4253
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

4254
        (void) memset((void*)sfcnPeriod, 0,

4255
                      sizeof(time_T)*1);

4256
        (void) memset((void*)sfcnOffset, 0,

4257
                      sizeof(time_T)*1);

4258
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

4259
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

4260
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

4261


4262
        /* Set up the mdlInfo pointer */

4263
# ifdef USE_RTMODEL

4264


4265
        {

4266
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

4267
              struct _ssBlkInfo2));

4268
          ss_VALIDATE_MEMORY(rts,blkInfo2);

4269
          ssSetBlkInfo2Ptr(childS, blkInfo2);

4270
        }

4271


4272
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

4273


4274
# else

4275


4276
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

4277


4278
# endif                                /* USE_RTMODEL */

4279


4280
        /* Allocate memory of model methods 2 */

4281
        {

4282
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

4283
            malloc(sizeof(struct _ssSFcnModelMethods2));

4284
          ss_VALIDATE_MEMORY(rts,methods2);

4285
          ssSetModelMethods2(childS, methods2);

4286
        }

4287


4288
        /* Allocate memory of model methods 3 */

4289
        {

4290
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

4291
            malloc(sizeof(struct _ssSFcnModelMethods3));

4292
          ss_VALIDATE_MEMORY(rts,methods3);

4293
          ssSetModelMethods3(childS, methods3);

4294
        }

4295


4296
        /* Allocate memory for states auxilliary information */

4297
        {

4298
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

4299
            (sizeof(struct _ssStatesInfo2));

4300
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

4301
            malloc(sizeof(ssPeriodicStatesInfo));

4302
          ss_VALIDATE_MEMORY(rts,statesInfo2);

4303
          ssSetStatesInfo2(childS, statesInfo2);

4304
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

4305
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

4306
        }

4307


4308
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

4309
          RegNumInputPorts);

4310
        ssSetRegNumInputPortsFcnArg(childS,childS);

4311


4312
        /* inputs */

4313
        {

4314
          struct _ssPortInputs *inputPortInfo =

4315
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

4316
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

4317
          _ssSetNumInputPorts(childS, 3);

4318
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

4319


4320
          /* port 0 */

4321
          {

4322
            real32_T const **sfcnUPtrs = (real32_T const **)

4323
              malloc(1 * sizeof(real32_T *));

4324
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4325
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

4326
              ssGetLocalBlockIO(rts))->Sum6;

4327
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

4328
            _ssSetInputPortNumDimensions(childS, 0, 1);

4329
            ssSetInputPortWidth(childS, 0, 1);

4330
          }

4331


4332
          /* port 1 */

4333
          {

4334
            real32_T const **sfcnUPtrs = (real32_T const **)

4335
              malloc(1 * sizeof(real32_T *));

4336
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4337
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

4338
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

4339
            _ssSetInputPortNumDimensions(childS, 1, 1);

4340
            ssSetInputPortWidth(childS, 1, 1);

4341
          }

4342


4343
          /* port 2 */

4344
          {

4345
            real32_T const **sfcnUPtrs = (real32_T const **)

4346
              malloc(1 * sizeof(real32_T *));

4347
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4348
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;

4349
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

4350
            _ssSetInputPortNumDimensions(childS, 2, 1);

4351
            ssSetInputPortWidth(childS, 2, 1);

4352
          }

4353
        }

4354


4355
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

4356
          RegNumOutputPorts);

4357
        ssSetRegNumOutputPortsFcnArg(childS,childS);

4358


4359
        /* outputs */

4360
        {

4361
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

4362
            calloc(1, sizeof(struct _ssPortOutputs));

4363
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

4364
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

4365
          _ssSetNumOutputPorts(childS, 1);

4366


4367
          /* port 0 */

4368
          {

4369
            _ssSetOutputPortNumDimensions(childS, 0, 1);

4370
            ssSetOutputPortWidth(childS, 0, 1);

4371
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

4372
              ssGetLocalBlockIO(rts))->GeneratedSFunction1));

4373
          }

4374
        }

4375


4376
        /* path info */

4377
        _ssSetModelName(childS, "SaturationLimiter_sf");

4378
        _ssSetPath(childS,

4379
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter2/Generated S-Function1");

4380
        if (ssGetRTModel(rts) == (NULL)) {

4381
          _ssSetParentSS(childS, rts);

4382
          _ssSetRootSS(childS, ssGetRootSS(rts));

4383
        } else {

4384
          ssSetRTModel(childS,ssGetRTModel(rts));

4385
          _ssSetParentSS(childS, (NULL));

4386
          _ssSetRootSS(childS, childS);

4387
        }

4388


4389
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

4390
        (childS)->regDataType.arg1 = ((void *)(childS));

4391
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

4392
          FcnSetErrorStatus);

4393
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

4394
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

4395
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

4396
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

4397


4398
        /* registration */

4399
#if defined(MATLAB_MEX_FILE)

4400


4401
        {

4402
          int_T i;

4403
          mxArray *plhs[1];

4404
          mxArray *prhs[4];

4405
          double *pr;

4406
          volatile int_T *intS = (int_T *)&childS;

4407
          int_T addrlen = sizeof(SimStruct *);

4408
          int_T m = addrlen/sizeof(int_T) + 1;

4409
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

4410
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

4411
          pr = mxGetPr(prhs[1]);

4412
          for (i = 0; i < m - 1; i++) {

4413
            pr[i] = (double)intS[i];

4414
          }

4415


4416
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

4417
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

4418
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

4419


4420
          /* Reset port dimensions info functions because the S-function

4421
           * and accelerator mex-files explicitly set their dimensions,

4422
           * i.e., they are not dynamically sized. For this case, the

4423
           * mex-file is responsible for the dimensions info memory

4424
           * and Simulink should not free it. This is achieved by

4425
           * setting the following two methods to NULL.

4426
           */

4427
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

4428
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

4429


4430
          /*

4431
           * Setup function pointers and call mdlInitializeSizes via

4432
           * simulink.c

4433
           */

4434
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

4435
          mxDestroyArray(plhs[0]);

4436
          mxDestroyArray(prhs[0]);

4437
          mxDestroyArray(prhs[1]);

4438
          mxDestroyArray(prhs[2]);

4439
          mxDestroyArray(prhs[3]);

4440
        }

4441


4442
#else

4443


4444
        {

4445
          SaturationLimiter_sf(childS);

4446
          sfcnInitializeSizes(childS);

4447
        }

4448


4449
#endif

4450


4451
        sfcnInitializeSampleTimes(childS);

4452


4453
        /* adjust sample time */

4454
        ssSetSampleTime(childS, 0, 0.0);

4455
        ssSetOffsetTime(childS, 0, 0.0);

4456
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

4457


4458
        /* set compiled values of dynamic vector attributes */

4459
        ssSetNumNonsampledZCs(childS, 0);

4460


4461
        /* Update connectivity flags for each port */

4462
        _ssSetInputPortConnected(childS, 0, 1);

4463
        _ssSetInputPortConnected(childS, 1, 1);

4464
        _ssSetInputPortConnected(childS, 2, 1);

4465
        _ssSetOutputPortConnected(childS, 0, 1);

4466
        _ssSetOutputPortBeingMerged(childS, 0, 0);

4467


4468
        /* Update the BufferDstPort flags for each input port */

4469
        _ssSetInputPortBufferDstPort(childS, 0, -1);

4470
        _ssSetInputPortBufferDstPort(childS, 1, -1);

4471
        _ssSetInputPortBufferDstPort(childS, 2, -1);

4472
      }

4473


4474
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S96>/Generated S-Function (Gain_sf) */

4475
      {

4476
        SimStruct *childS = ssGetSFunction(rts, 16);

4477


4478
        /* timing info */

4479
        time_T *sfcnPeriod;

4480
        time_T *sfcnOffset;

4481
        int_T *sfcnTsMap;

4482
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

4483
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

4484
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

4485
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

4486
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

4487
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

4488
        (void) memset((void*)sfcnPeriod, 0,

4489
                      sizeof(time_T)*1);

4490
        (void) memset((void*)sfcnOffset, 0,

4491
                      sizeof(time_T)*1);

4492
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

4493
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

4494
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

4495


4496
        /* Set up the mdlInfo pointer */

4497
# ifdef USE_RTMODEL

4498


4499
        {

4500
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

4501
              struct _ssBlkInfo2));

4502
          ss_VALIDATE_MEMORY(rts,blkInfo2);

4503
          ssSetBlkInfo2Ptr(childS, blkInfo2);

4504
        }

4505


4506
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

4507


4508
# else

4509


4510
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

4511


4512
# endif                                /* USE_RTMODEL */

4513


4514
        /* Allocate memory of model methods 2 */

4515
        {

4516
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

4517
            malloc(sizeof(struct _ssSFcnModelMethods2));

4518
          ss_VALIDATE_MEMORY(rts,methods2);

4519
          ssSetModelMethods2(childS, methods2);

4520
        }

4521


4522
        /* Allocate memory of model methods 3 */

4523
        {

4524
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

4525
            malloc(sizeof(struct _ssSFcnModelMethods3));

4526
          ss_VALIDATE_MEMORY(rts,methods3);

4527
          ssSetModelMethods3(childS, methods3);

4528
        }

4529


4530
        /* Allocate memory for states auxilliary information */

4531
        {

4532
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

4533
            (sizeof(struct _ssStatesInfo2));

4534
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

4535
            malloc(sizeof(ssPeriodicStatesInfo));

4536
          ss_VALIDATE_MEMORY(rts,statesInfo2);

4537
          ssSetStatesInfo2(childS, statesInfo2);

4538
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

4539
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

4540
        }

4541


4542
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

4543
          RegNumInputPorts);

4544
        ssSetRegNumInputPortsFcnArg(childS,childS);

4545


4546
        /* inputs */

4547
        {

4548
          struct _ssPortInputs *inputPortInfo =

4549
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

4550
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

4551
          _ssSetNumInputPorts(childS, 2);

4552
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

4553


4554
          /* port 0 */

4555
          {

4556
            real32_T const **sfcnUPtrs = (real32_T const **)

4557
              malloc(1 * sizeof(real32_T *));

4558
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4559
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

4560
              ssGetLocalBlockIO(rts))->GeneratedSFunction1;

4561
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

4562
            _ssSetInputPortNumDimensions(childS, 0, 1);

4563
            ssSetInputPortWidth(childS, 0, 1);

4564
          }

4565


4566
          /* port 1 */

4567
          {

4568
            real32_T const **sfcnUPtrs = (real32_T const **)

4569
              malloc(1 * sizeof(real32_T *));

4570
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4571
            sfcnUPtrs[0] = (real32_T const *)

4572
              &AFCS_MODEL1_ConstP.Constant22_Value;

4573
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

4574
            _ssSetInputPortNumDimensions(childS, 1, 1);

4575
            ssSetInputPortWidth(childS, 1, 1);

4576
          }

4577
        }

4578


4579
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

4580
          RegNumOutputPorts);

4581
        ssSetRegNumOutputPortsFcnArg(childS,childS);

4582


4583
        /* outputs */

4584
        {

4585
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

4586
            calloc(1, sizeof(struct _ssPortOutputs));

4587
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

4588
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

4589
          _ssSetNumOutputPorts(childS, 1);

4590


4591
          /* port 0 */

4592
          {

4593
            _ssSetOutputPortNumDimensions(childS, 0, 1);

4594
            ssSetOutputPortWidth(childS, 0, 1);

4595
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

4596
              ssGetLocalBlockIO(rts))->GeneratedSFunction_o));

4597
          }

4598
        }

4599


4600
        /* path info */

4601
        _ssSetModelName(childS, "Gain_sf");

4602
        _ssSetPath(childS,

4603
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/gain2/Generated S-Function");

4604
        if (ssGetRTModel(rts) == (NULL)) {

4605
          _ssSetParentSS(childS, rts);

4606
          _ssSetRootSS(childS, ssGetRootSS(rts));

4607
        } else {

4608
          ssSetRTModel(childS,ssGetRTModel(rts));

4609
          _ssSetParentSS(childS, (NULL));

4610
          _ssSetRootSS(childS, childS);

4611
        }

4612


4613
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

4614
        (childS)->regDataType.arg1 = ((void *)(childS));

4615
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

4616
          FcnSetErrorStatus);

4617
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

4618
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

4619
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

4620
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

4621


4622
        /* registration */

4623
#if defined(MATLAB_MEX_FILE)

4624


4625
        {

4626
          int_T i;

4627
          mxArray *plhs[1];

4628
          mxArray *prhs[4];

4629
          double *pr;

4630
          volatile int_T *intS = (int_T *)&childS;

4631
          int_T addrlen = sizeof(SimStruct *);

4632
          int_T m = addrlen/sizeof(int_T) + 1;

4633
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

4634
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

4635
          pr = mxGetPr(prhs[1]);

4636
          for (i = 0; i < m - 1; i++) {

4637
            pr[i] = (double)intS[i];

4638
          }

4639


4640
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

4641
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

4642
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

4643


4644
          /* Reset port dimensions info functions because the S-function

4645
           * and accelerator mex-files explicitly set their dimensions,

4646
           * i.e., they are not dynamically sized. For this case, the

4647
           * mex-file is responsible for the dimensions info memory

4648
           * and Simulink should not free it. This is achieved by

4649
           * setting the following two methods to NULL.

4650
           */

4651
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

4652
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

4653


4654
          /*

4655
           * Setup function pointers and call mdlInitializeSizes via

4656
           * simulink.c

4657
           */

4658
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

4659
          mxDestroyArray(plhs[0]);

4660
          mxDestroyArray(prhs[0]);

4661
          mxDestroyArray(prhs[1]);

4662
          mxDestroyArray(prhs[2]);

4663
          mxDestroyArray(prhs[3]);

4664
        }

4665


4666
#else

4667


4668
        {

4669
          Gain_sf(childS);

4670
          sfcnInitializeSizes(childS);

4671
        }

4672


4673
#endif

4674


4675
        sfcnInitializeSampleTimes(childS);

4676


4677
        /* adjust sample time */

4678
        ssSetSampleTime(childS, 0, 0.0);

4679
        ssSetOffsetTime(childS, 0, 0.0);

4680
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

4681


4682
        /* set compiled values of dynamic vector attributes */

4683
        ssSetNumNonsampledZCs(childS, 0);

4684


4685
        /* Update connectivity flags for each port */

4686
        _ssSetInputPortConnected(childS, 0, 1);

4687
        _ssSetInputPortConnected(childS, 1, 1);

4688
        _ssSetOutputPortConnected(childS, 0, 1);

4689
        _ssSetOutputPortBeingMerged(childS, 0, 0);

4690


4691
        /* Update the BufferDstPort flags for each input port */

4692
        _ssSetInputPortBufferDstPort(childS, 0, -1);

4693
        _ssSetInputPortBufferDstPort(childS, 1, -1);

4694
      }

4695


4696
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S93>/Generated S-Function1 (SaturationLimiter_sf) */

4697
      {

4698
        SimStruct *childS = ssGetSFunction(rts, 17);

4699


4700
        /* timing info */

4701
        time_T *sfcnPeriod;

4702
        time_T *sfcnOffset;

4703
        int_T *sfcnTsMap;

4704
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

4705
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

4706
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

4707
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

4708
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

4709
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

4710
        (void) memset((void*)sfcnPeriod, 0,

4711
                      sizeof(time_T)*1);

4712
        (void) memset((void*)sfcnOffset, 0,

4713
                      sizeof(time_T)*1);

4714
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

4715
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

4716
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

4717


4718
        /* Set up the mdlInfo pointer */

4719
# ifdef USE_RTMODEL

4720


4721
        {

4722
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

4723
              struct _ssBlkInfo2));

4724
          ss_VALIDATE_MEMORY(rts,blkInfo2);

4725
          ssSetBlkInfo2Ptr(childS, blkInfo2);

4726
        }

4727


4728
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

4729


4730
# else

4731


4732
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

4733


4734
# endif                                /* USE_RTMODEL */

4735


4736
        /* Allocate memory of model methods 2 */

4737
        {

4738
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

4739
            malloc(sizeof(struct _ssSFcnModelMethods2));

4740
          ss_VALIDATE_MEMORY(rts,methods2);

4741
          ssSetModelMethods2(childS, methods2);

4742
        }

4743


4744
        /* Allocate memory of model methods 3 */

4745
        {

4746
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

4747
            malloc(sizeof(struct _ssSFcnModelMethods3));

4748
          ss_VALIDATE_MEMORY(rts,methods3);

4749
          ssSetModelMethods3(childS, methods3);

4750
        }

4751


4752
        /* Allocate memory for states auxilliary information */

4753
        {

4754
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

4755
            (sizeof(struct _ssStatesInfo2));

4756
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

4757
            malloc(sizeof(ssPeriodicStatesInfo));

4758
          ss_VALIDATE_MEMORY(rts,statesInfo2);

4759
          ssSetStatesInfo2(childS, statesInfo2);

4760
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

4761
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

4762
        }

4763


4764
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

4765
          RegNumInputPorts);

4766
        ssSetRegNumInputPortsFcnArg(childS,childS);

4767


4768
        /* inputs */

4769
        {

4770
          struct _ssPortInputs *inputPortInfo =

4771
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

4772
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

4773
          _ssSetNumInputPorts(childS, 3);

4774
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

4775


4776
          /* port 0 */

4777
          {

4778
            real32_T const **sfcnUPtrs = (real32_T const **)

4779
              malloc(1 * sizeof(real32_T *));

4780
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4781
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

4782
              ssGetLocalBlockIO(rts))->Divide2;

4783
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

4784
            _ssSetInputPortNumDimensions(childS, 0, 1);

4785
            ssSetInputPortWidth(childS, 0, 1);

4786
          }

4787


4788
          /* port 1 */

4789
          {

4790
            real32_T const **sfcnUPtrs = (real32_T const **)

4791
              malloc(1 * sizeof(real32_T *));

4792
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4793
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

4794
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

4795
            _ssSetInputPortNumDimensions(childS, 1, 1);

4796
            ssSetInputPortWidth(childS, 1, 1);

4797
          }

4798


4799
          /* port 2 */

4800
          {

4801
            real32_T const **sfcnUPtrs = (real32_T const **)

4802
              malloc(1 * sizeof(real32_T *));

4803
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

4804
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

4805
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

4806
            _ssSetInputPortNumDimensions(childS, 2, 1);

4807
            ssSetInputPortWidth(childS, 2, 1);

4808
          }

4809
        }

4810


4811
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

4812
          RegNumOutputPorts);

4813
        ssSetRegNumOutputPortsFcnArg(childS,childS);

4814


4815
        /* outputs */

4816
        {

4817
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

4818
            calloc(1, sizeof(struct _ssPortOutputs));

4819
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

4820
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

4821
          _ssSetNumOutputPorts(childS, 1);

4822


4823
          /* port 0 */

4824
          {

4825
            _ssSetOutputPortNumDimensions(childS, 0, 1);

4826
            ssSetOutputPortWidth(childS, 0, 1);

4827
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

4828
              ssGetLocalBlockIO(rts))->Switch6_d));

4829
          }

4830
        }

4831


4832
        /* path info */

4833
        _ssSetModelName(childS, "SaturationLimiter_sf");

4834
        _ssSetPath(childS,

4835
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter3/Generated S-Function1");

4836
        if (ssGetRTModel(rts) == (NULL)) {

4837
          _ssSetParentSS(childS, rts);

4838
          _ssSetRootSS(childS, ssGetRootSS(rts));

4839
        } else {

4840
          ssSetRTModel(childS,ssGetRTModel(rts));

4841
          _ssSetParentSS(childS, (NULL));

4842
          _ssSetRootSS(childS, childS);

4843
        }

4844


4845
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

4846
        (childS)->regDataType.arg1 = ((void *)(childS));

4847
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

4848
          FcnSetErrorStatus);

4849
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

4850
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

4851
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

4852
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

4853


4854
        /* registration */

4855
#if defined(MATLAB_MEX_FILE)

4856


4857
        {

4858
          int_T i;

4859
          mxArray *plhs[1];

4860
          mxArray *prhs[4];

4861
          double *pr;

4862
          volatile int_T *intS = (int_T *)&childS;

4863
          int_T addrlen = sizeof(SimStruct *);

4864
          int_T m = addrlen/sizeof(int_T) + 1;

4865
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

4866
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

4867
          pr = mxGetPr(prhs[1]);

4868
          for (i = 0; i < m - 1; i++) {

4869
            pr[i] = (double)intS[i];

4870
          }

4871


4872
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

4873
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

4874
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

4875


4876
          /* Reset port dimensions info functions because the S-function

4877
           * and accelerator mex-files explicitly set their dimensions,

4878
           * i.e., they are not dynamically sized. For this case, the

4879
           * mex-file is responsible for the dimensions info memory

4880
           * and Simulink should not free it. This is achieved by

4881
           * setting the following two methods to NULL.

4882
           */

4883
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

4884
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

4885


4886
          /*

4887
           * Setup function pointers and call mdlInitializeSizes via

4888
           * simulink.c

4889
           */

4890
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

4891
          mxDestroyArray(plhs[0]);

4892
          mxDestroyArray(prhs[0]);

4893
          mxDestroyArray(prhs[1]);

4894
          mxDestroyArray(prhs[2]);

4895
          mxDestroyArray(prhs[3]);

4896
        }

4897


4898
#else

4899


4900
        {

4901
          SaturationLimiter_sf(childS);

4902
          sfcnInitializeSizes(childS);

4903
        }

4904


4905
#endif

4906


4907
        sfcnInitializeSampleTimes(childS);

4908


4909
        /* adjust sample time */

4910
        ssSetSampleTime(childS, 0, 0.0);

4911
        ssSetOffsetTime(childS, 0, 0.0);

4912
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

4913


4914
        /* set compiled values of dynamic vector attributes */

4915
        ssSetNumNonsampledZCs(childS, 0);

4916


4917
        /* Update connectivity flags for each port */

4918
        _ssSetInputPortConnected(childS, 0, 1);

4919
        _ssSetInputPortConnected(childS, 1, 1);

4920
        _ssSetInputPortConnected(childS, 2, 1);

4921
        _ssSetOutputPortConnected(childS, 0, 1);

4922
        _ssSetOutputPortBeingMerged(childS, 0, 0);

4923


4924
        /* Update the BufferDstPort flags for each input port */

4925
        _ssSetInputPortBufferDstPort(childS, 0, -1);

4926
        _ssSetInputPortBufferDstPort(childS, 1, -1);

4927
        _ssSetInputPortBufferDstPort(childS, 2, -1);

4928
      }

4929


4930
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S97>/Generated S-Function (Gain_sf) */

4931
      {

4932
        SimStruct *childS = ssGetSFunction(rts, 18);

4933


4934
        /* timing info */

4935
        time_T *sfcnPeriod;

4936
        time_T *sfcnOffset;

4937
        int_T *sfcnTsMap;

4938
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

4939
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

4940
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

4941
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

4942
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

4943
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

4944
        (void) memset((void*)sfcnPeriod, 0,

4945
                      sizeof(time_T)*1);

4946
        (void) memset((void*)sfcnOffset, 0,

4947
                      sizeof(time_T)*1);

4948
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

4949
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

4950
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

4951


4952
        /* Set up the mdlInfo pointer */

4953
# ifdef USE_RTMODEL

4954


4955
        {

4956
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

4957
              struct _ssBlkInfo2));

4958
          ss_VALIDATE_MEMORY(rts,blkInfo2);

4959
          ssSetBlkInfo2Ptr(childS, blkInfo2);

4960
        }

4961


4962
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

4963


4964
# else

4965


4966
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

4967


4968
# endif                                /* USE_RTMODEL */

4969


4970
        /* Allocate memory of model methods 2 */

4971
        {

4972
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

4973
            malloc(sizeof(struct _ssSFcnModelMethods2));

4974
          ss_VALIDATE_MEMORY(rts,methods2);

4975
          ssSetModelMethods2(childS, methods2);

4976
        }

4977


4978
        /* Allocate memory of model methods 3 */

4979
        {

4980
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

4981
            malloc(sizeof(struct _ssSFcnModelMethods3));

4982
          ss_VALIDATE_MEMORY(rts,methods3);

4983
          ssSetModelMethods3(childS, methods3);

4984
        }

4985


4986
        /* Allocate memory for states auxilliary information */

4987
        {

4988
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

4989
            (sizeof(struct _ssStatesInfo2));

4990
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

4991
            malloc(sizeof(ssPeriodicStatesInfo));

4992
          ss_VALIDATE_MEMORY(rts,statesInfo2);

4993
          ssSetStatesInfo2(childS, statesInfo2);

4994
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

4995
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

4996
        }

4997


4998
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

4999
          RegNumInputPorts);

5000
        ssSetRegNumInputPortsFcnArg(childS,childS);

5001


5002
        /* inputs */

5003
        {

5004
          struct _ssPortInputs *inputPortInfo =

5005
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

5006
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

5007
          _ssSetNumInputPorts(childS, 2);

5008
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

5009


5010
          /* port 0 */

5011
          {

5012
            real32_T const **sfcnUPtrs = (real32_T const **)

5013
              malloc(1 * sizeof(real32_T *));

5014
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5015
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

5016
              ssGetLocalBlockIO(rts))->GeneratedSFunction_o;

5017
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

5018
            _ssSetInputPortNumDimensions(childS, 0, 1);

5019
            ssSetInputPortWidth(childS, 0, 1);

5020
          }

5021


5022
          /* port 1 */

5023
          {

5024
            real32_T const **sfcnUPtrs = (real32_T const **)

5025
              malloc(1 * sizeof(real32_T *));

5026
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5027
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

5028
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

5029
            _ssSetInputPortNumDimensions(childS, 1, 1);

5030
            ssSetInputPortWidth(childS, 1, 1);

5031
          }

5032
        }

5033


5034
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

5035
          RegNumOutputPorts);

5036
        ssSetRegNumOutputPortsFcnArg(childS,childS);

5037


5038
        /* outputs */

5039
        {

5040
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

5041
            calloc(1, sizeof(struct _ssPortOutputs));

5042
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

5043
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

5044
          _ssSetNumOutputPorts(childS, 1);

5045


5046
          /* port 0 */

5047
          {

5048
            _ssSetOutputPortNumDimensions(childS, 0, 1);

5049
            ssSetOutputPortWidth(childS, 0, 1);

5050
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

5051
              ssGetLocalBlockIO(rts))->GeneratedSFunction_jq));

5052
          }

5053
        }

5054


5055
        /* path info */

5056
        _ssSetModelName(childS, "Gain_sf");

5057
        _ssSetPath(childS,

5058
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/gain4/Generated S-Function");

5059
        if (ssGetRTModel(rts) == (NULL)) {

5060
          _ssSetParentSS(childS, rts);

5061
          _ssSetRootSS(childS, ssGetRootSS(rts));

5062
        } else {

5063
          ssSetRTModel(childS,ssGetRTModel(rts));

5064
          _ssSetParentSS(childS, (NULL));

5065
          _ssSetRootSS(childS, childS);

5066
        }

5067


5068
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

5069
        (childS)->regDataType.arg1 = ((void *)(childS));

5070
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

5071
          FcnSetErrorStatus);

5072
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

5073
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

5074
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

5075
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

5076


5077
        /* registration */

5078
#if defined(MATLAB_MEX_FILE)

5079


5080
        {

5081
          int_T i;

5082
          mxArray *plhs[1];

5083
          mxArray *prhs[4];

5084
          double *pr;

5085
          volatile int_T *intS = (int_T *)&childS;

5086
          int_T addrlen = sizeof(SimStruct *);

5087
          int_T m = addrlen/sizeof(int_T) + 1;

5088
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

5089
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

5090
          pr = mxGetPr(prhs[1]);

5091
          for (i = 0; i < m - 1; i++) {

5092
            pr[i] = (double)intS[i];

5093
          }

5094


5095
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

5096
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

5097
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

5098


5099
          /* Reset port dimensions info functions because the S-function

5100
           * and accelerator mex-files explicitly set their dimensions,

5101
           * i.e., they are not dynamically sized. For this case, the

5102
           * mex-file is responsible for the dimensions info memory

5103
           * and Simulink should not free it. This is achieved by

5104
           * setting the following two methods to NULL.

5105
           */

5106
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

5107
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

5108


5109
          /*

5110
           * Setup function pointers and call mdlInitializeSizes via

5111
           * simulink.c

5112
           */

5113
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

5114
          mxDestroyArray(plhs[0]);

5115
          mxDestroyArray(prhs[0]);

5116
          mxDestroyArray(prhs[1]);

5117
          mxDestroyArray(prhs[2]);

5118
          mxDestroyArray(prhs[3]);

5119
        }

5120


5121
#else

5122


5123
        {

5124
          Gain_sf(childS);

5125
          sfcnInitializeSizes(childS);

5126
        }

5127


5128
#endif

5129


5130
        sfcnInitializeSampleTimes(childS);

5131


5132
        /* adjust sample time */

5133
        ssSetSampleTime(childS, 0, 0.0);

5134
        ssSetOffsetTime(childS, 0, 0.0);

5135
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

5136


5137
        /* set compiled values of dynamic vector attributes */

5138
        ssSetNumNonsampledZCs(childS, 0);

5139


5140
        /* Update connectivity flags for each port */

5141
        _ssSetInputPortConnected(childS, 0, 1);

5142
        _ssSetInputPortConnected(childS, 1, 1);

5143
        _ssSetOutputPortConnected(childS, 0, 1);

5144
        _ssSetOutputPortBeingMerged(childS, 0, 0);

5145


5146
        /* Update the BufferDstPort flags for each input port */

5147
        _ssSetInputPortBufferDstPort(childS, 0, -1);

5148
        _ssSetInputPortBufferDstPort(childS, 1, -1);

5149
      }

5150


5151
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S89>/Generated S-Function3 (IntegratorLimited_sf) */

5152
      {

5153
        SimStruct *childS = ssGetSFunction(rts, 19);

5154


5155
        /* timing info */

5156
        time_T *sfcnPeriod;

5157
        time_T *sfcnOffset;

5158
        int_T *sfcnTsMap;

5159
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

5160
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

5161
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

5162
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

5163
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

5164
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

5165
        (void) memset((void*)sfcnPeriod, 0,

5166
                      sizeof(time_T)*1);

5167
        (void) memset((void*)sfcnOffset, 0,

5168
                      sizeof(time_T)*1);

5169
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

5170
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

5171
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

5172


5173
        /* Set up the mdlInfo pointer */

5174
# ifdef USE_RTMODEL

5175


5176
        {

5177
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

5178
              struct _ssBlkInfo2));

5179
          ss_VALIDATE_MEMORY(rts,blkInfo2);

5180
          ssSetBlkInfo2Ptr(childS, blkInfo2);

5181
        }

5182


5183
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

5184


5185
# else

5186


5187
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

5188


5189
# endif                                /* USE_RTMODEL */

5190


5191
        /* Allocate memory of model methods 2 */

5192
        {

5193
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

5194
            malloc(sizeof(struct _ssSFcnModelMethods2));

5195
          ss_VALIDATE_MEMORY(rts,methods2);

5196
          ssSetModelMethods2(childS, methods2);

5197
        }

5198


5199
        /* Allocate memory of model methods 3 */

5200
        {

5201
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

5202
            malloc(sizeof(struct _ssSFcnModelMethods3));

5203
          ss_VALIDATE_MEMORY(rts,methods3);

5204
          ssSetModelMethods3(childS, methods3);

5205
        }

5206


5207
        /* Allocate memory for states auxilliary information */

5208
        {

5209
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

5210
            (sizeof(struct _ssStatesInfo2));

5211
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

5212
            malloc(sizeof(ssPeriodicStatesInfo));

5213
          ss_VALIDATE_MEMORY(rts,statesInfo2);

5214
          ssSetStatesInfo2(childS, statesInfo2);

5215
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

5216
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

5217
        }

5218


5219
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

5220
          RegNumInputPorts);

5221
        ssSetRegNumInputPortsFcnArg(childS,childS);

5222


5223
        /* inputs */

5224
        {

5225
          struct _ssPortInputs *inputPortInfo =

5226
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

5227
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

5228
          _ssSetNumInputPorts(childS, 7);

5229
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

5230


5231
          /* port 0 */

5232
          {

5233
            real32_T const **sfcnUPtrs = (real32_T const **)

5234
              malloc(1 * sizeof(real32_T *));

5235
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5236
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

5237
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

5238
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

5239
            _ssSetInputPortNumDimensions(childS, 0, 1);

5240
            ssSetInputPortWidth(childS, 0, 1);

5241
          }

5242


5243
          /* port 1 */

5244
          {

5245
            int8_T const **sfcnUPtrs = (int8_T const **)

5246
              malloc(1 * sizeof(int8_T *));

5247
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5248
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

5249
              ssGetLocalBlockIO(rts))->DataTypeConversion3_c;

5250
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

5251
            _ssSetInputPortNumDimensions(childS, 1, 1);

5252
            ssSetInputPortWidth(childS, 1, 1);

5253
          }

5254


5255
          /* port 2 */

5256
          {

5257
            real32_T const **sfcnUPtrs = (real32_T const **)

5258
              malloc(1 * sizeof(real32_T *));

5259
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5260
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

5261
              ssGetLocalBlockIO(rts))->Sum8;

5262
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

5263
            _ssSetInputPortNumDimensions(childS, 2, 1);

5264
            ssSetInputPortWidth(childS, 2, 1);

5265
          }

5266


5267
          /* port 3 */

5268
          {

5269
            real32_T const **sfcnUPtrs = (real32_T const **)

5270
              malloc(1 * sizeof(real32_T *));

5271
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5272
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

5273
              ssGetLocalBlockIO(rts))->Sum8;

5274
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

5275
            _ssSetInputPortNumDimensions(childS, 3, 1);

5276
            ssSetInputPortWidth(childS, 3, 1);

5277
          }

5278


5279
          /* port 4 */

5280
          {

5281
            real32_T const **sfcnUPtrs = (real32_T const **)

5282
              malloc(1 * sizeof(real32_T *));

5283
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5284
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

5285
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

5286
            _ssSetInputPortNumDimensions(childS, 4, 1);

5287
            ssSetInputPortWidth(childS, 4, 1);

5288
          }

5289


5290
          /* port 5 */

5291
          {

5292
            real32_T const **sfcnUPtrs = (real32_T const **)

5293
              malloc(1 * sizeof(real32_T *));

5294
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5295
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

5296
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

5297
            _ssSetInputPortNumDimensions(childS, 5, 1);

5298
            ssSetInputPortWidth(childS, 5, 1);

5299
          }

5300


5301
          /* port 6 */

5302
          {

5303
            real32_T const **sfcnUPtrs = (real32_T const **)

5304
              malloc(1 * sizeof(real32_T *));

5305
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5306
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

5307
              ssGetLocalBlockIO(rts))->GeneratedSFunction_jq;

5308
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

5309
            _ssSetInputPortNumDimensions(childS, 6, 1);

5310
            ssSetInputPortWidth(childS, 6, 1);

5311
          }

5312
        }

5313


5314
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

5315
          RegNumOutputPorts);

5316
        ssSetRegNumOutputPortsFcnArg(childS,childS);

5317


5318
        /* outputs */

5319
        {

5320
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

5321
            calloc(1, sizeof(struct _ssPortOutputs));

5322
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

5323
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

5324
          _ssSetNumOutputPorts(childS, 1);

5325


5326
          /* port 0 */

5327
          {

5328
            _ssSetOutputPortNumDimensions(childS, 0, 1);

5329
            ssSetOutputPortWidth(childS, 0, 1);

5330
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

5331
              ssGetLocalBlockIO(rts))->Switch6_d));

5332
          }

5333
        }

5334


5335
        /* path info */

5336
        _ssSetModelName(childS, "IntegratorLimited_sf");

5337
        _ssSetPath(childS,

5338
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Integrator Limited1/Generated S-Function3");

5339
        if (ssGetRTModel(rts) == (NULL)) {

5340
          _ssSetParentSS(childS, rts);

5341
          _ssSetRootSS(childS, ssGetRootSS(rts));

5342
        } else {

5343
          ssSetRTModel(childS,ssGetRTModel(rts));

5344
          _ssSetParentSS(childS, (NULL));

5345
          _ssSetRootSS(childS, childS);

5346
        }

5347


5348
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

5349


5350
        /* work vectors */

5351
        {

5352
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

5353
            (4 * sizeof(struct _ssDWorkRecord));

5354
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

5355
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

5356
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

5357
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

5358
          ssSetSFcnDWork(childS, dWorkRecord);

5359
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

5360
          _ssSetNumDWork(childS, 4);

5361


5362
          /* DWORK0 */

5363
          ssSetDWorkWidth(childS, 0, 1);

5364
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

5365
          ssSetDWorkComplexSignal(childS, 0, 0);

5366
          ssSetDWorkUsedAsDState(childS, 0, 1);

5367
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 162))[0]);

5368


5369
          /* DWORK1 */

5370
          ssSetDWorkWidth(childS, 1, 1);

5371
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

5372
          ssSetDWorkComplexSignal(childS, 1, 0);

5373
          ssSetDWorkUsedAsDState(childS, 1, 1);

5374
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 163))[0]);

5375


5376
          /* DWORK2 */

5377
          ssSetDWorkWidth(childS, 2, 1);

5378
          ssSetDWorkDataType(childS, 2,SS_INT8);

5379
          ssSetDWorkComplexSignal(childS, 2, 0);

5380
          ssSetDWorkUsedAsDState(childS, 2, 1);

5381
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 389))[0]);

5382


5383
          /* DWORK3 */

5384
          ssSetDWorkWidth(childS, 3, 1);

5385
          ssSetDWorkDataType(childS, 3,SS_INT8);

5386
          ssSetDWorkComplexSignal(childS, 3, 0);

5387
          ssSetDWorkUsedAsDState(childS, 3, 1);

5388
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 390))[0]);

5389
        }

5390


5391
        (childS)->regDataType.arg1 = ((void *)(childS));

5392
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

5393
          FcnSetErrorStatus);

5394
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

5395
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

5396
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

5397
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

5398


5399
        /* registration */

5400
#if defined(MATLAB_MEX_FILE)

5401


5402
        {

5403
          int_T i;

5404
          mxArray *plhs[1];

5405
          mxArray *prhs[4];

5406
          double *pr;

5407
          volatile int_T *intS = (int_T *)&childS;

5408
          int_T addrlen = sizeof(SimStruct *);

5409
          int_T m = addrlen/sizeof(int_T) + 1;

5410
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

5411
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

5412
          pr = mxGetPr(prhs[1]);

5413
          for (i = 0; i < m - 1; i++) {

5414
            pr[i] = (double)intS[i];

5415
          }

5416


5417
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

5418
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

5419
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

5420


5421
          /* Reset port dimensions info functions because the S-function

5422
           * and accelerator mex-files explicitly set their dimensions,

5423
           * i.e., they are not dynamically sized. For this case, the

5424
           * mex-file is responsible for the dimensions info memory

5425
           * and Simulink should not free it. This is achieved by

5426
           * setting the following two methods to NULL.

5427
           */

5428
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

5429
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

5430


5431
          /*

5432
           * Setup function pointers and call mdlInitializeSizes via

5433
           * simulink.c

5434
           */

5435
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

5436
          mxDestroyArray(plhs[0]);

5437
          mxDestroyArray(prhs[0]);

5438
          mxDestroyArray(prhs[1]);

5439
          mxDestroyArray(prhs[2]);

5440
          mxDestroyArray(prhs[3]);

5441
        }

5442


5443
#else

5444


5445
        {

5446
          IntegratorLimited_sf(childS);

5447
          sfcnInitializeSizes(childS);

5448
        }

5449


5450
#endif

5451


5452
        sfcnInitializeSampleTimes(childS);

5453


5454
        /* adjust sample time */

5455
        ssSetSampleTime(childS, 0, 0.0);

5456
        ssSetOffsetTime(childS, 0, 0.0);

5457
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

5458


5459
        /* set compiled values of dynamic vector attributes */

5460
        ssSetNumNonsampledZCs(childS, 0);

5461


5462
        /* Update connectivity flags for each port */

5463
        _ssSetInputPortConnected(childS, 0, 1);

5464
        _ssSetInputPortConnected(childS, 1, 1);

5465
        _ssSetInputPortConnected(childS, 2, 1);

5466
        _ssSetInputPortConnected(childS, 3, 1);

5467
        _ssSetInputPortConnected(childS, 4, 1);

5468
        _ssSetInputPortConnected(childS, 5, 1);

5469
        _ssSetInputPortConnected(childS, 6, 1);

5470
        _ssSetOutputPortConnected(childS, 0, 1);

5471
        _ssSetOutputPortBeingMerged(childS, 0, 0);

5472


5473
        /* Update the BufferDstPort flags for each input port */

5474
        _ssSetInputPortBufferDstPort(childS, 0, -1);

5475
        _ssSetInputPortBufferDstPort(childS, 1, -1);

5476
        _ssSetInputPortBufferDstPort(childS, 2, -1);

5477
        _ssSetInputPortBufferDstPort(childS, 3, -1);

5478
        _ssSetInputPortBufferDstPort(childS, 4, -1);

5479
        _ssSetInputPortBufferDstPort(childS, 5, -1);

5480
        _ssSetInputPortBufferDstPort(childS, 6, -1);

5481
      }

5482


5483
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S91>/Generated S-Function1 (SaturationLimiter_sf) */

5484
      {

5485
        SimStruct *childS = ssGetSFunction(rts, 20);

5486


5487
        /* timing info */

5488
        time_T *sfcnPeriod;

5489
        time_T *sfcnOffset;

5490
        int_T *sfcnTsMap;

5491
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

5492
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

5493
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

5494
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

5495
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

5496
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

5497
        (void) memset((void*)sfcnPeriod, 0,

5498
                      sizeof(time_T)*1);

5499
        (void) memset((void*)sfcnOffset, 0,

5500
                      sizeof(time_T)*1);

5501
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

5502
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

5503
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

5504


5505
        /* Set up the mdlInfo pointer */

5506
# ifdef USE_RTMODEL

5507


5508
        {

5509
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

5510
              struct _ssBlkInfo2));

5511
          ss_VALIDATE_MEMORY(rts,blkInfo2);

5512
          ssSetBlkInfo2Ptr(childS, blkInfo2);

5513
        }

5514


5515
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

5516


5517
# else

5518


5519
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

5520


5521
# endif                                /* USE_RTMODEL */

5522


5523
        /* Allocate memory of model methods 2 */

5524
        {

5525
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

5526
            malloc(sizeof(struct _ssSFcnModelMethods2));

5527
          ss_VALIDATE_MEMORY(rts,methods2);

5528
          ssSetModelMethods2(childS, methods2);

5529
        }

5530


5531
        /* Allocate memory of model methods 3 */

5532
        {

5533
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

5534
            malloc(sizeof(struct _ssSFcnModelMethods3));

5535
          ss_VALIDATE_MEMORY(rts,methods3);

5536
          ssSetModelMethods3(childS, methods3);

5537
        }

5538


5539
        /* Allocate memory for states auxilliary information */

5540
        {

5541
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

5542
            (sizeof(struct _ssStatesInfo2));

5543
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

5544
            malloc(sizeof(ssPeriodicStatesInfo));

5545
          ss_VALIDATE_MEMORY(rts,statesInfo2);

5546
          ssSetStatesInfo2(childS, statesInfo2);

5547
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

5548
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

5549
        }

5550


5551
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

5552
          RegNumInputPorts);

5553
        ssSetRegNumInputPortsFcnArg(childS,childS);

5554


5555
        /* inputs */

5556
        {

5557
          struct _ssPortInputs *inputPortInfo =

5558
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

5559
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

5560
          _ssSetNumInputPorts(childS, 3);

5561
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

5562


5563
          /* port 0 */

5564
          {

5565
            real32_T const **sfcnUPtrs = (real32_T const **)

5566
              malloc(1 * sizeof(real32_T *));

5567
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5568
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

5569
              ssGetLocalBlockIO(rts))->Sum1_j;

5570
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

5571
            _ssSetInputPortNumDimensions(childS, 0, 1);

5572
            ssSetInputPortWidth(childS, 0, 1);

5573
          }

5574


5575
          /* port 1 */

5576
          {

5577
            real32_T const **sfcnUPtrs = (real32_T const **)

5578
              malloc(1 * sizeof(real32_T *));

5579
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5580
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

5581
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

5582
            _ssSetInputPortNumDimensions(childS, 1, 1);

5583
            ssSetInputPortWidth(childS, 1, 1);

5584
          }

5585


5586
          /* port 2 */

5587
          {

5588
            real32_T const **sfcnUPtrs = (real32_T const **)

5589
              malloc(1 * sizeof(real32_T *));

5590
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5591
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

5592
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

5593
            _ssSetInputPortNumDimensions(childS, 2, 1);

5594
            ssSetInputPortWidth(childS, 2, 1);

5595
          }

5596
        }

5597


5598
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

5599
          RegNumOutputPorts);

5600
        ssSetRegNumOutputPortsFcnArg(childS,childS);

5601


5602
        /* outputs */

5603
        {

5604
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

5605
            calloc(1, sizeof(struct _ssPortOutputs));

5606
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

5607
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

5608
          _ssSetNumOutputPorts(childS, 1);

5609


5610
          /* port 0 */

5611
          {

5612
            _ssSetOutputPortNumDimensions(childS, 0, 1);

5613
            ssSetOutputPortWidth(childS, 0, 1);

5614
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

5615
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_h));

5616
          }

5617
        }

5618


5619
        /* path info */

5620
        _ssSetModelName(childS, "SaturationLimiter_sf");

5621
        _ssSetPath(childS,

5622
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter1/Generated S-Function1");

5623
        if (ssGetRTModel(rts) == (NULL)) {

5624
          _ssSetParentSS(childS, rts);

5625
          _ssSetRootSS(childS, ssGetRootSS(rts));

5626
        } else {

5627
          ssSetRTModel(childS,ssGetRTModel(rts));

5628
          _ssSetParentSS(childS, (NULL));

5629
          _ssSetRootSS(childS, childS);

5630
        }

5631


5632
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

5633
        (childS)->regDataType.arg1 = ((void *)(childS));

5634
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

5635
          FcnSetErrorStatus);

5636
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

5637
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

5638
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

5639
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

5640


5641
        /* registration */

5642
#if defined(MATLAB_MEX_FILE)

5643


5644
        {

5645
          int_T i;

5646
          mxArray *plhs[1];

5647
          mxArray *prhs[4];

5648
          double *pr;

5649
          volatile int_T *intS = (int_T *)&childS;

5650
          int_T addrlen = sizeof(SimStruct *);

5651
          int_T m = addrlen/sizeof(int_T) + 1;

5652
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

5653
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

5654
          pr = mxGetPr(prhs[1]);

5655
          for (i = 0; i < m - 1; i++) {

5656
            pr[i] = (double)intS[i];

5657
          }

5658


5659
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

5660
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

5661
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

5662


5663
          /* Reset port dimensions info functions because the S-function

5664
           * and accelerator mex-files explicitly set their dimensions,

5665
           * i.e., they are not dynamically sized. For this case, the

5666
           * mex-file is responsible for the dimensions info memory

5667
           * and Simulink should not free it. This is achieved by

5668
           * setting the following two methods to NULL.

5669
           */

5670
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

5671
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

5672


5673
          /*

5674
           * Setup function pointers and call mdlInitializeSizes via

5675
           * simulink.c

5676
           */

5677
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

5678
          mxDestroyArray(plhs[0]);

5679
          mxDestroyArray(prhs[0]);

5680
          mxDestroyArray(prhs[1]);

5681
          mxDestroyArray(prhs[2]);

5682
          mxDestroyArray(prhs[3]);

5683
        }

5684


5685
#else

5686


5687
        {

5688
          SaturationLimiter_sf(childS);

5689
          sfcnInitializeSizes(childS);

5690
        }

5691


5692
#endif

5693


5694
        sfcnInitializeSampleTimes(childS);

5695


5696
        /* adjust sample time */

5697
        ssSetSampleTime(childS, 0, 0.0);

5698
        ssSetOffsetTime(childS, 0, 0.0);

5699
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

5700


5701
        /* set compiled values of dynamic vector attributes */

5702
        ssSetNumNonsampledZCs(childS, 0);

5703


5704
        /* Update connectivity flags for each port */

5705
        _ssSetInputPortConnected(childS, 0, 1);

5706
        _ssSetInputPortConnected(childS, 1, 1);

5707
        _ssSetInputPortConnected(childS, 2, 1);

5708
        _ssSetOutputPortConnected(childS, 0, 1);

5709
        _ssSetOutputPortBeingMerged(childS, 0, 0);

5710


5711
        /* Update the BufferDstPort flags for each input port */

5712
        _ssSetInputPortBufferDstPort(childS, 0, -1);

5713
        _ssSetInputPortBufferDstPort(childS, 1, -1);

5714
        _ssSetInputPortBufferDstPort(childS, 2, -1);

5715
      }

5716


5717
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S95>/Generated S-Function (Gain_sf) */

5718
      {

5719
        SimStruct *childS = ssGetSFunction(rts, 21);

5720


5721
        /* timing info */

5722
        time_T *sfcnPeriod;

5723
        time_T *sfcnOffset;

5724
        int_T *sfcnTsMap;

5725
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

5726
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

5727
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

5728
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

5729
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

5730
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

5731
        (void) memset((void*)sfcnPeriod, 0,

5732
                      sizeof(time_T)*1);

5733
        (void) memset((void*)sfcnOffset, 0,

5734
                      sizeof(time_T)*1);

5735
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

5736
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

5737
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

5738


5739
        /* Set up the mdlInfo pointer */

5740
# ifdef USE_RTMODEL

5741


5742
        {

5743
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

5744
              struct _ssBlkInfo2));

5745
          ss_VALIDATE_MEMORY(rts,blkInfo2);

5746
          ssSetBlkInfo2Ptr(childS, blkInfo2);

5747
        }

5748


5749
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

5750


5751
# else

5752


5753
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

5754


5755
# endif                                /* USE_RTMODEL */

5756


5757
        /* Allocate memory of model methods 2 */

5758
        {

5759
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

5760
            malloc(sizeof(struct _ssSFcnModelMethods2));

5761
          ss_VALIDATE_MEMORY(rts,methods2);

5762
          ssSetModelMethods2(childS, methods2);

5763
        }

5764


5765
        /* Allocate memory of model methods 3 */

5766
        {

5767
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

5768
            malloc(sizeof(struct _ssSFcnModelMethods3));

5769
          ss_VALIDATE_MEMORY(rts,methods3);

5770
          ssSetModelMethods3(childS, methods3);

5771
        }

5772


5773
        /* Allocate memory for states auxilliary information */

5774
        {

5775
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

5776
            (sizeof(struct _ssStatesInfo2));

5777
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

5778
            malloc(sizeof(ssPeriodicStatesInfo));

5779
          ss_VALIDATE_MEMORY(rts,statesInfo2);

5780
          ssSetStatesInfo2(childS, statesInfo2);

5781
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

5782
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

5783
        }

5784


5785
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

5786
          RegNumInputPorts);

5787
        ssSetRegNumInputPortsFcnArg(childS,childS);

5788


5789
        /* inputs */

5790
        {

5791
          struct _ssPortInputs *inputPortInfo =

5792
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

5793
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

5794
          _ssSetNumInputPorts(childS, 2);

5795
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

5796


5797
          /* port 0 */

5798
          {

5799
            real32_T const **sfcnUPtrs = (real32_T const **)

5800
              malloc(1 * sizeof(real32_T *));

5801
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5802
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

5803
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_h;

5804
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

5805
            _ssSetInputPortNumDimensions(childS, 0, 1);

5806
            ssSetInputPortWidth(childS, 0, 1);

5807
          }

5808


5809
          /* port 1 */

5810
          {

5811
            real32_T const **sfcnUPtrs = (real32_T const **)

5812
              malloc(1 * sizeof(real32_T *));

5813
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

5814
            sfcnUPtrs[0] = (real32_T const *)

5815
              &AFCS_MODEL1_ConstP.Constant13_Value_n;

5816
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

5817
            _ssSetInputPortNumDimensions(childS, 1, 1);

5818
            ssSetInputPortWidth(childS, 1, 1);

5819
          }

5820
        }

5821


5822
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

5823
          RegNumOutputPorts);

5824
        ssSetRegNumOutputPortsFcnArg(childS,childS);

5825


5826
        /* outputs */

5827
        {

5828
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

5829
            calloc(1, sizeof(struct _ssPortOutputs));

5830
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

5831
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

5832
          _ssSetNumOutputPorts(childS, 1);

5833


5834
          /* port 0 */

5835
          {

5836
            _ssSetOutputPortNumDimensions(childS, 0, 1);

5837
            ssSetOutputPortWidth(childS, 0, 1);

5838
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

5839
              ssGetLocalBlockIO(rts))->Saturation8));

5840
          }

5841
        }

5842


5843
        /* path info */

5844
        _ssSetModelName(childS, "Gain_sf");

5845
        _ssSetPath(childS,

5846
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/gain/Generated S-Function");

5847
        if (ssGetRTModel(rts) == (NULL)) {

5848
          _ssSetParentSS(childS, rts);

5849
          _ssSetRootSS(childS, ssGetRootSS(rts));

5850
        } else {

5851
          ssSetRTModel(childS,ssGetRTModel(rts));

5852
          _ssSetParentSS(childS, (NULL));

5853
          _ssSetRootSS(childS, childS);

5854
        }

5855


5856
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

5857
        (childS)->regDataType.arg1 = ((void *)(childS));

5858
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

5859
          FcnSetErrorStatus);

5860
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

5861
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

5862
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

5863
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

5864


5865
        /* registration */

5866
#if defined(MATLAB_MEX_FILE)

5867


5868
        {

5869
          int_T i;

5870
          mxArray *plhs[1];

5871
          mxArray *prhs[4];

5872
          double *pr;

5873
          volatile int_T *intS = (int_T *)&childS;

5874
          int_T addrlen = sizeof(SimStruct *);

5875
          int_T m = addrlen/sizeof(int_T) + 1;

5876
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

5877
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

5878
          pr = mxGetPr(prhs[1]);

5879
          for (i = 0; i < m - 1; i++) {

5880
            pr[i] = (double)intS[i];

5881
          }

5882


5883
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

5884
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

5885
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

5886


5887
          /* Reset port dimensions info functions because the S-function

5888
           * and accelerator mex-files explicitly set their dimensions,

5889
           * i.e., they are not dynamically sized. For this case, the

5890
           * mex-file is responsible for the dimensions info memory

5891
           * and Simulink should not free it. This is achieved by

5892
           * setting the following two methods to NULL.

5893
           */

5894
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

5895
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

5896


5897
          /*

5898
           * Setup function pointers and call mdlInitializeSizes via

5899
           * simulink.c

5900
           */

5901
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

5902
          mxDestroyArray(plhs[0]);

5903
          mxDestroyArray(prhs[0]);

5904
          mxDestroyArray(prhs[1]);

5905
          mxDestroyArray(prhs[2]);

5906
          mxDestroyArray(prhs[3]);

5907
        }

5908


5909
#else

5910


5911
        {

5912
          Gain_sf(childS);

5913
          sfcnInitializeSizes(childS);

5914
        }

5915


5916
#endif

5917


5918
        sfcnInitializeSampleTimes(childS);

5919


5920
        /* adjust sample time */

5921
        ssSetSampleTime(childS, 0, 0.0);

5922
        ssSetOffsetTime(childS, 0, 0.0);

5923
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

5924


5925
        /* set compiled values of dynamic vector attributes */

5926
        ssSetNumNonsampledZCs(childS, 0);

5927


5928
        /* Update connectivity flags for each port */

5929
        _ssSetInputPortConnected(childS, 0, 1);

5930
        _ssSetInputPortConnected(childS, 1, 1);

5931
        _ssSetOutputPortConnected(childS, 0, 1);

5932
        _ssSetOutputPortBeingMerged(childS, 0, 0);

5933


5934
        /* Update the BufferDstPort flags for each input port */

5935
        _ssSetInputPortBufferDstPort(childS, 0, -1);

5936
        _ssSetInputPortBufferDstPort(childS, 1, -1);

5937
      }

5938


5939
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S90>/Generated S-Function2 (LeadLagFilter_sf) */

5940
      {

5941
        SimStruct *childS = ssGetSFunction(rts, 22);

5942


5943
        /* timing info */

5944
        time_T *sfcnPeriod;

5945
        time_T *sfcnOffset;

5946
        int_T *sfcnTsMap;

5947
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

5948
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

5949
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

5950
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

5951
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

5952
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

5953
        (void) memset((void*)sfcnPeriod, 0,

5954
                      sizeof(time_T)*1);

5955
        (void) memset((void*)sfcnOffset, 0,

5956
                      sizeof(time_T)*1);

5957
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

5958
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

5959
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

5960


5961
        /* Set up the mdlInfo pointer */

5962
# ifdef USE_RTMODEL

5963


5964
        {

5965
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

5966
              struct _ssBlkInfo2));

5967
          ss_VALIDATE_MEMORY(rts,blkInfo2);

5968
          ssSetBlkInfo2Ptr(childS, blkInfo2);

5969
        }

5970


5971
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

5972


5973
# else

5974


5975
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

5976


5977
# endif                                /* USE_RTMODEL */

5978


5979
        /* Allocate memory of model methods 2 */

5980
        {

5981
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

5982
            malloc(sizeof(struct _ssSFcnModelMethods2));

5983
          ss_VALIDATE_MEMORY(rts,methods2);

5984
          ssSetModelMethods2(childS, methods2);

5985
        }

5986


5987
        /* Allocate memory of model methods 3 */

5988
        {

5989
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

5990
            malloc(sizeof(struct _ssSFcnModelMethods3));

5991
          ss_VALIDATE_MEMORY(rts,methods3);

5992
          ssSetModelMethods3(childS, methods3);

5993
        }

5994


5995
        /* Allocate memory for states auxilliary information */

5996
        {

5997
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

5998
            (sizeof(struct _ssStatesInfo2));

5999
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

6000
            malloc(sizeof(ssPeriodicStatesInfo));

6001
          ss_VALIDATE_MEMORY(rts,statesInfo2);

6002
          ssSetStatesInfo2(childS, statesInfo2);

6003
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

6004
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

6005
        }

6006


6007
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

6008
          RegNumInputPorts);

6009
        ssSetRegNumInputPortsFcnArg(childS,childS);

6010


6011
        /* inputs */

6012
        {

6013
          struct _ssPortInputs *inputPortInfo =

6014
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

6015
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

6016
          _ssSetNumInputPorts(childS, 7);

6017
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

6018


6019
          /* port 0 */

6020
          {

6021
            real32_T const **sfcnUPtrs = (real32_T const **)

6022
              malloc(1 * sizeof(real32_T *));

6023
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6024
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6025
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

6026
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

6027
            _ssSetInputPortNumDimensions(childS, 0, 1);

6028
            ssSetInputPortWidth(childS, 0, 1);

6029
          }

6030


6031
          /* port 1 */

6032
          {

6033
            int8_T const **sfcnUPtrs = (int8_T const **)

6034
              malloc(1 * sizeof(int8_T *));

6035
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6036
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

6037
              ssGetLocalBlockIO(rts))->DataTypeConversion3_c;

6038
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

6039
            _ssSetInputPortNumDimensions(childS, 1, 1);

6040
            ssSetInputPortWidth(childS, 1, 1);

6041
          }

6042


6043
          /* port 2 */

6044
          {

6045
            real32_T const **sfcnUPtrs = (real32_T const **)

6046
              malloc(1 * sizeof(real32_T *));

6047
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6048
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

6049
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

6050
            _ssSetInputPortNumDimensions(childS, 2, 1);

6051
            ssSetInputPortWidth(childS, 2, 1);

6052
          }

6053


6054
          /* port 3 */

6055
          {

6056
            real32_T const **sfcnUPtrs = (real32_T const **)

6057
              malloc(1 * sizeof(real32_T *));

6058
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6059
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;

6060
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

6061
            _ssSetInputPortNumDimensions(childS, 3, 1);

6062
            ssSetInputPortWidth(childS, 3, 1);

6063
          }

6064


6065
          /* port 4 */

6066
          {

6067
            real32_T const **sfcnUPtrs = (real32_T const **)

6068
              malloc(1 * sizeof(real32_T *));

6069
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6070
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6071
              ssGetLocalBlockIO(rts))->Switch_aj;

6072
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

6073
            _ssSetInputPortNumDimensions(childS, 4, 1);

6074
            ssSetInputPortWidth(childS, 4, 1);

6075
          }

6076


6077
          /* port 5 */

6078
          {

6079
            real32_T const **sfcnUPtrs = (real32_T const **)

6080
              malloc(1 * sizeof(real32_T *));

6081
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6082
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6083
              ssGetLocalBlockIO(rts))->Switch_aj;

6084
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

6085
            _ssSetInputPortNumDimensions(childS, 5, 1);

6086
            ssSetInputPortWidth(childS, 5, 1);

6087
          }

6088


6089
          /* port 6 */

6090
          {

6091
            real32_T const **sfcnUPtrs = (real32_T const **)

6092
              malloc(1 * sizeof(real32_T *));

6093
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6094
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6095
              ssGetLocalBlockIO(rts))->Divide;

6096
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

6097
            _ssSetInputPortNumDimensions(childS, 6, 1);

6098
            ssSetInputPortWidth(childS, 6, 1);

6099
          }

6100
        }

6101


6102
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

6103
          RegNumOutputPorts);

6104
        ssSetRegNumOutputPortsFcnArg(childS,childS);

6105


6106
        /* outputs */

6107
        {

6108
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

6109
            calloc(1, sizeof(struct _ssPortOutputs));

6110
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

6111
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

6112
          _ssSetNumOutputPorts(childS, 1);

6113


6114
          /* port 0 */

6115
          {

6116
            _ssSetOutputPortNumDimensions(childS, 0, 1);

6117
            ssSetOutputPortWidth(childS, 0, 1);

6118
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

6119
              ssGetLocalBlockIO(rts))->GeneratedSFunction2));

6120
          }

6121
        }

6122


6123
        /* path info */

6124
        _ssSetModelName(childS, "LeadLagFilter_sf");

6125
        _ssSetPath(childS,

6126
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Lead lag/Generated S-Function2");

6127
        if (ssGetRTModel(rts) == (NULL)) {

6128
          _ssSetParentSS(childS, rts);

6129
          _ssSetRootSS(childS, ssGetRootSS(rts));

6130
        } else {

6131
          ssSetRTModel(childS,ssGetRTModel(rts));

6132
          _ssSetParentSS(childS, (NULL));

6133
          _ssSetRootSS(childS, childS);

6134
        }

6135


6136
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

6137


6138
        /* work vectors */

6139
        {

6140
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

6141
            (4 * sizeof(struct _ssDWorkRecord));

6142
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

6143
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

6144
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

6145
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

6146
          ssSetSFcnDWork(childS, dWorkRecord);

6147
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

6148
          _ssSetNumDWork(childS, 4);

6149


6150
          /* DWORK0 */

6151
          ssSetDWorkWidth(childS, 0, 1);

6152
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

6153
          ssSetDWorkComplexSignal(childS, 0, 0);

6154
          ssSetDWorkUsedAsDState(childS, 0, 1);

6155
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 164))[0]);

6156


6157
          /* DWORK1 */

6158
          ssSetDWorkWidth(childS, 1, 1);

6159
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

6160
          ssSetDWorkComplexSignal(childS, 1, 0);

6161
          ssSetDWorkUsedAsDState(childS, 1, 1);

6162
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 165))[0]);

6163


6164
          /* DWORK2 */

6165
          ssSetDWorkWidth(childS, 2, 1);

6166
          ssSetDWorkDataType(childS, 2,SS_INT8);

6167
          ssSetDWorkComplexSignal(childS, 2, 0);

6168
          ssSetDWorkUsedAsDState(childS, 2, 1);

6169
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 391))[0]);

6170


6171
          /* DWORK3 */

6172
          ssSetDWorkWidth(childS, 3, 1);

6173
          ssSetDWorkDataType(childS, 3,SS_INT8);

6174
          ssSetDWorkComplexSignal(childS, 3, 0);

6175
          ssSetDWorkUsedAsDState(childS, 3, 1);

6176
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 392))[0]);

6177
        }

6178


6179
        (childS)->regDataType.arg1 = ((void *)(childS));

6180
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

6181
          FcnSetErrorStatus);

6182
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

6183
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

6184
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

6185
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

6186


6187
        /* registration */

6188
#if defined(MATLAB_MEX_FILE)

6189


6190
        {

6191
          int_T i;

6192
          mxArray *plhs[1];

6193
          mxArray *prhs[4];

6194
          double *pr;

6195
          volatile int_T *intS = (int_T *)&childS;

6196
          int_T addrlen = sizeof(SimStruct *);

6197
          int_T m = addrlen/sizeof(int_T) + 1;

6198
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

6199
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

6200
          pr = mxGetPr(prhs[1]);

6201
          for (i = 0; i < m - 1; i++) {

6202
            pr[i] = (double)intS[i];

6203
          }

6204


6205
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

6206
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

6207
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

6208


6209
          /* Reset port dimensions info functions because the S-function

6210
           * and accelerator mex-files explicitly set their dimensions,

6211
           * i.e., they are not dynamically sized. For this case, the

6212
           * mex-file is responsible for the dimensions info memory

6213
           * and Simulink should not free it. This is achieved by

6214
           * setting the following two methods to NULL.

6215
           */

6216
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

6217
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

6218


6219
          /*

6220
           * Setup function pointers and call mdlInitializeSizes via

6221
           * simulink.c

6222
           */

6223
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

6224
          mxDestroyArray(plhs[0]);

6225
          mxDestroyArray(prhs[0]);

6226
          mxDestroyArray(prhs[1]);

6227
          mxDestroyArray(prhs[2]);

6228
          mxDestroyArray(prhs[3]);

6229
        }

6230


6231
#else

6232


6233
        {

6234
          LeadLagFilter_sf(childS);

6235
          sfcnInitializeSizes(childS);

6236
        }

6237


6238
#endif

6239


6240
        sfcnInitializeSampleTimes(childS);

6241


6242
        /* adjust sample time */

6243
        ssSetSampleTime(childS, 0, 0.0);

6244
        ssSetOffsetTime(childS, 0, 0.0);

6245
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

6246


6247
        /* set compiled values of dynamic vector attributes */

6248
        ssSetNumNonsampledZCs(childS, 0);

6249


6250
        /* Update connectivity flags for each port */

6251
        _ssSetInputPortConnected(childS, 0, 1);

6252
        _ssSetInputPortConnected(childS, 1, 1);

6253
        _ssSetInputPortConnected(childS, 2, 1);

6254
        _ssSetInputPortConnected(childS, 3, 1);

6255
        _ssSetInputPortConnected(childS, 4, 1);

6256
        _ssSetInputPortConnected(childS, 5, 1);

6257
        _ssSetInputPortConnected(childS, 6, 1);

6258
        _ssSetOutputPortConnected(childS, 0, 1);

6259
        _ssSetOutputPortBeingMerged(childS, 0, 0);

6260


6261
        /* Update the BufferDstPort flags for each input port */

6262
        _ssSetInputPortBufferDstPort(childS, 0, -1);

6263
        _ssSetInputPortBufferDstPort(childS, 1, -1);

6264
        _ssSetInputPortBufferDstPort(childS, 2, -1);

6265
        _ssSetInputPortBufferDstPort(childS, 3, -1);

6266
        _ssSetInputPortBufferDstPort(childS, 4, -1);

6267
        _ssSetInputPortBufferDstPort(childS, 5, -1);

6268
        _ssSetInputPortBufferDstPort(childS, 6, -1);

6269
      }

6270


6271
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S94>/Generated S-Function1 (SaturationLimiter_sf) */

6272
      {

6273
        SimStruct *childS = ssGetSFunction(rts, 23);

6274


6275
        /* timing info */

6276
        time_T *sfcnPeriod;

6277
        time_T *sfcnOffset;

6278
        int_T *sfcnTsMap;

6279
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

6280
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

6281
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

6282
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

6283
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

6284
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

6285
        (void) memset((void*)sfcnPeriod, 0,

6286
                      sizeof(time_T)*1);

6287
        (void) memset((void*)sfcnOffset, 0,

6288
                      sizeof(time_T)*1);

6289
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

6290
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

6291
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

6292


6293
        /* Set up the mdlInfo pointer */

6294
# ifdef USE_RTMODEL

6295


6296
        {

6297
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

6298
              struct _ssBlkInfo2));

6299
          ss_VALIDATE_MEMORY(rts,blkInfo2);

6300
          ssSetBlkInfo2Ptr(childS, blkInfo2);

6301
        }

6302


6303
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

6304


6305
# else

6306


6307
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

6308


6309
# endif                                /* USE_RTMODEL */

6310


6311
        /* Allocate memory of model methods 2 */

6312
        {

6313
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

6314
            malloc(sizeof(struct _ssSFcnModelMethods2));

6315
          ss_VALIDATE_MEMORY(rts,methods2);

6316
          ssSetModelMethods2(childS, methods2);

6317
        }

6318


6319
        /* Allocate memory of model methods 3 */

6320
        {

6321
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

6322
            malloc(sizeof(struct _ssSFcnModelMethods3));

6323
          ss_VALIDATE_MEMORY(rts,methods3);

6324
          ssSetModelMethods3(childS, methods3);

6325
        }

6326


6327
        /* Allocate memory for states auxilliary information */

6328
        {

6329
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

6330
            (sizeof(struct _ssStatesInfo2));

6331
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

6332
            malloc(sizeof(ssPeriodicStatesInfo));

6333
          ss_VALIDATE_MEMORY(rts,statesInfo2);

6334
          ssSetStatesInfo2(childS, statesInfo2);

6335
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

6336
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

6337
        }

6338


6339
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

6340
          RegNumInputPorts);

6341
        ssSetRegNumInputPortsFcnArg(childS,childS);

6342


6343
        /* inputs */

6344
        {

6345
          struct _ssPortInputs *inputPortInfo =

6346
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

6347
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

6348
          _ssSetNumInputPorts(childS, 3);

6349
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

6350


6351
          /* port 0 */

6352
          {

6353
            real32_T const **sfcnUPtrs = (real32_T const **)

6354
              malloc(1 * sizeof(real32_T *));

6355
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6356
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6357
              ssGetLocalBlockIO(rts))->GeneratedSFunction2;

6358
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

6359
            _ssSetInputPortNumDimensions(childS, 0, 1);

6360
            ssSetInputPortWidth(childS, 0, 1);

6361
          }

6362


6363
          /* port 1 */

6364
          {

6365
            real32_T const **sfcnUPtrs = (real32_T const **)

6366
              malloc(1 * sizeof(real32_T *));

6367
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6368
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6369
              ssGetLocalBlockIO(rts))->Product1_m;

6370
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

6371
            _ssSetInputPortNumDimensions(childS, 1, 1);

6372
            ssSetInputPortWidth(childS, 1, 1);

6373
          }

6374


6375
          /* port 2 */

6376
          {

6377
            real32_T const **sfcnUPtrs = (real32_T const **)

6378
              malloc(1 * sizeof(real32_T *));

6379
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6380
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6381
              ssGetLocalBlockIO(rts))->Product_pp;

6382
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

6383
            _ssSetInputPortNumDimensions(childS, 2, 1);

6384
            ssSetInputPortWidth(childS, 2, 1);

6385
          }

6386
        }

6387


6388
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

6389
          RegNumOutputPorts);

6390
        ssSetRegNumOutputPortsFcnArg(childS,childS);

6391


6392
        /* outputs */

6393
        {

6394
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

6395
            calloc(1, sizeof(struct _ssPortOutputs));

6396
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

6397
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

6398
          _ssSetNumOutputPorts(childS, 1);

6399


6400
          /* port 0 */

6401
          {

6402
            _ssSetOutputPortNumDimensions(childS, 0, 1);

6403
            ssSetOutputPortWidth(childS, 0, 1);

6404
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

6405
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_b));

6406
          }

6407
        }

6408


6409
        /* path info */

6410
        _ssSetModelName(childS, "SaturationLimiter_sf");

6411
        _ssSetPath(childS,

6412
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter4/Generated S-Function1");

6413
        if (ssGetRTModel(rts) == (NULL)) {

6414
          _ssSetParentSS(childS, rts);

6415
          _ssSetRootSS(childS, ssGetRootSS(rts));

6416
        } else {

6417
          ssSetRTModel(childS,ssGetRTModel(rts));

6418
          _ssSetParentSS(childS, (NULL));

6419
          _ssSetRootSS(childS, childS);

6420
        }

6421


6422
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

6423
        (childS)->regDataType.arg1 = ((void *)(childS));

6424
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

6425
          FcnSetErrorStatus);

6426
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

6427
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

6428
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

6429
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

6430


6431
        /* registration */

6432
#if defined(MATLAB_MEX_FILE)

6433


6434
        {

6435
          int_T i;

6436
          mxArray *plhs[1];

6437
          mxArray *prhs[4];

6438
          double *pr;

6439
          volatile int_T *intS = (int_T *)&childS;

6440
          int_T addrlen = sizeof(SimStruct *);

6441
          int_T m = addrlen/sizeof(int_T) + 1;

6442
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

6443
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

6444
          pr = mxGetPr(prhs[1]);

6445
          for (i = 0; i < m - 1; i++) {

6446
            pr[i] = (double)intS[i];

6447
          }

6448


6449
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

6450
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

6451
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

6452


6453
          /* Reset port dimensions info functions because the S-function

6454
           * and accelerator mex-files explicitly set their dimensions,

6455
           * i.e., they are not dynamically sized. For this case, the

6456
           * mex-file is responsible for the dimensions info memory

6457
           * and Simulink should not free it. This is achieved by

6458
           * setting the following two methods to NULL.

6459
           */

6460
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

6461
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

6462


6463
          /*

6464
           * Setup function pointers and call mdlInitializeSizes via

6465
           * simulink.c

6466
           */

6467
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

6468
          mxDestroyArray(plhs[0]);

6469
          mxDestroyArray(prhs[0]);

6470
          mxDestroyArray(prhs[1]);

6471
          mxDestroyArray(prhs[2]);

6472
          mxDestroyArray(prhs[3]);

6473
        }

6474


6475
#else

6476


6477
        {

6478
          SaturationLimiter_sf(childS);

6479
          sfcnInitializeSizes(childS);

6480
        }

6481


6482
#endif

6483


6484
        sfcnInitializeSampleTimes(childS);

6485


6486
        /* adjust sample time */

6487
        ssSetSampleTime(childS, 0, 0.0);

6488
        ssSetOffsetTime(childS, 0, 0.0);

6489
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

6490


6491
        /* set compiled values of dynamic vector attributes */

6492
        ssSetNumNonsampledZCs(childS, 0);

6493


6494
        /* Update connectivity flags for each port */

6495
        _ssSetInputPortConnected(childS, 0, 1);

6496
        _ssSetInputPortConnected(childS, 1, 1);

6497
        _ssSetInputPortConnected(childS, 2, 1);

6498
        _ssSetOutputPortConnected(childS, 0, 1);

6499
        _ssSetOutputPortBeingMerged(childS, 0, 0);

6500


6501
        /* Update the BufferDstPort flags for each input port */

6502
        _ssSetInputPortBufferDstPort(childS, 0, -1);

6503
        _ssSetInputPortBufferDstPort(childS, 1, -1);

6504
        _ssSetInputPortBufferDstPort(childS, 2, -1);

6505
      }

6506


6507
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S87>/Generated S-Function4 (LagFilter_sf) */

6508
      {

6509
        SimStruct *childS = ssGetSFunction(rts, 24);

6510


6511
        /* timing info */

6512
        time_T *sfcnPeriod;

6513
        time_T *sfcnOffset;

6514
        int_T *sfcnTsMap;

6515
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

6516
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

6517
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

6518
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

6519
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

6520
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

6521
        (void) memset((void*)sfcnPeriod, 0,

6522
                      sizeof(time_T)*1);

6523
        (void) memset((void*)sfcnOffset, 0,

6524
                      sizeof(time_T)*1);

6525
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

6526
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

6527
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

6528


6529
        /* Set up the mdlInfo pointer */

6530
# ifdef USE_RTMODEL

6531


6532
        {

6533
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

6534
              struct _ssBlkInfo2));

6535
          ss_VALIDATE_MEMORY(rts,blkInfo2);

6536
          ssSetBlkInfo2Ptr(childS, blkInfo2);

6537
        }

6538


6539
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

6540


6541
# else

6542


6543
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

6544


6545
# endif                                /* USE_RTMODEL */

6546


6547
        /* Allocate memory of model methods 2 */

6548
        {

6549
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

6550
            malloc(sizeof(struct _ssSFcnModelMethods2));

6551
          ss_VALIDATE_MEMORY(rts,methods2);

6552
          ssSetModelMethods2(childS, methods2);

6553
        }

6554


6555
        /* Allocate memory of model methods 3 */

6556
        {

6557
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

6558
            malloc(sizeof(struct _ssSFcnModelMethods3));

6559
          ss_VALIDATE_MEMORY(rts,methods3);

6560
          ssSetModelMethods3(childS, methods3);

6561
        }

6562


6563
        /* Allocate memory for states auxilliary information */

6564
        {

6565
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

6566
            (sizeof(struct _ssStatesInfo2));

6567
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

6568
            malloc(sizeof(ssPeriodicStatesInfo));

6569
          ss_VALIDATE_MEMORY(rts,statesInfo2);

6570
          ssSetStatesInfo2(childS, statesInfo2);

6571
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

6572
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

6573
        }

6574


6575
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

6576
          RegNumInputPorts);

6577
        ssSetRegNumInputPortsFcnArg(childS,childS);

6578


6579
        /* inputs */

6580
        {

6581
          struct _ssPortInputs *inputPortInfo =

6582
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

6583
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

6584
          _ssSetNumInputPorts(childS, 6);

6585
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

6586


6587
          /* port 0 */

6588
          {

6589
            real32_T const **sfcnUPtrs = (real32_T const **)

6590
              malloc(1 * sizeof(real32_T *));

6591
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6592
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6593
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

6594
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

6595
            _ssSetInputPortNumDimensions(childS, 0, 1);

6596
            ssSetInputPortWidth(childS, 0, 1);

6597
          }

6598


6599
          /* port 1 */

6600
          {

6601
            int8_T const **sfcnUPtrs = (int8_T const **)

6602
              malloc(1 * sizeof(int8_T *));

6603
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6604
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

6605
              ssGetLocalBlockIO(rts))->DataTypeConversion3_c;

6606
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

6607
            _ssSetInputPortNumDimensions(childS, 1, 1);

6608
            ssSetInputPortWidth(childS, 1, 1);

6609
          }

6610


6611
          /* port 2 */

6612
          {

6613
            real32_T const **sfcnUPtrs = (real32_T const **)

6614
              malloc(1 * sizeof(real32_T *));

6615
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6616
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

6617
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

6618
            _ssSetInputPortNumDimensions(childS, 2, 1);

6619
            ssSetInputPortWidth(childS, 2, 1);

6620
          }

6621


6622
          /* port 3 */

6623
          {

6624
            real32_T const **sfcnUPtrs = (real32_T const **)

6625
              malloc(1 * sizeof(real32_T *));

6626
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6627
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6628
              ssGetLocalBlockIO(rts))->Switch_aj;

6629
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

6630
            _ssSetInputPortNumDimensions(childS, 3, 1);

6631
            ssSetInputPortWidth(childS, 3, 1);

6632
          }

6633


6634
          /* port 4 */

6635
          {

6636
            real32_T const **sfcnUPtrs = (real32_T const **)

6637
              malloc(1 * sizeof(real32_T *));

6638
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6639
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6640
              ssGetLocalBlockIO(rts))->Switch_aj;

6641
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

6642
            _ssSetInputPortNumDimensions(childS, 4, 1);

6643
            ssSetInputPortWidth(childS, 4, 1);

6644
          }

6645


6646
          /* port 5 */

6647
          {

6648
            real32_T const **sfcnUPtrs = (real32_T const **)

6649
              malloc(1 * sizeof(real32_T *));

6650
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6651
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6652
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_b;

6653
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

6654
            _ssSetInputPortNumDimensions(childS, 5, 1);

6655
            ssSetInputPortWidth(childS, 5, 1);

6656
          }

6657
        }

6658


6659
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

6660
          RegNumOutputPorts);

6661
        ssSetRegNumOutputPortsFcnArg(childS,childS);

6662


6663
        /* outputs */

6664
        {

6665
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

6666
            calloc(1, sizeof(struct _ssPortOutputs));

6667
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

6668
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

6669
          _ssSetNumOutputPorts(childS, 1);

6670


6671
          /* port 0 */

6672
          {

6673
            _ssSetOutputPortNumDimensions(childS, 0, 1);

6674
            ssSetOutputPortWidth(childS, 0, 1);

6675
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

6676
              ssGetLocalBlockIO(rts))->GeneratedSFunction4));

6677
          }

6678
        }

6679


6680
        /* path info */

6681
        _ssSetModelName(childS, "LagFilter_sf");

6682
        _ssSetPath(childS,

6683
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/ lag filter/Generated S-Function4");

6684
        if (ssGetRTModel(rts) == (NULL)) {

6685
          _ssSetParentSS(childS, rts);

6686
          _ssSetRootSS(childS, ssGetRootSS(rts));

6687
        } else {

6688
          ssSetRTModel(childS,ssGetRTModel(rts));

6689
          _ssSetParentSS(childS, (NULL));

6690
          _ssSetRootSS(childS, childS);

6691
        }

6692


6693
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

6694


6695
        /* work vectors */

6696
        {

6697
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

6698
            (4 * sizeof(struct _ssDWorkRecord));

6699
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

6700
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

6701
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

6702
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

6703
          ssSetSFcnDWork(childS, dWorkRecord);

6704
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

6705
          _ssSetNumDWork(childS, 4);

6706


6707
          /* DWORK0 */

6708
          ssSetDWorkWidth(childS, 0, 1);

6709
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

6710
          ssSetDWorkComplexSignal(childS, 0, 0);

6711
          ssSetDWorkUsedAsDState(childS, 0, 1);

6712
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 166))[0]);

6713


6714
          /* DWORK1 */

6715
          ssSetDWorkWidth(childS, 1, 1);

6716
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

6717
          ssSetDWorkComplexSignal(childS, 1, 0);

6718
          ssSetDWorkUsedAsDState(childS, 1, 1);

6719
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 167))[0]);

6720


6721
          /* DWORK2 */

6722
          ssSetDWorkWidth(childS, 2, 1);

6723
          ssSetDWorkDataType(childS, 2,SS_INT8);

6724
          ssSetDWorkComplexSignal(childS, 2, 0);

6725
          ssSetDWorkUsedAsDState(childS, 2, 1);

6726
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 393))[0]);

6727


6728
          /* DWORK3 */

6729
          ssSetDWorkWidth(childS, 3, 1);

6730
          ssSetDWorkDataType(childS, 3,SS_INT8);

6731
          ssSetDWorkComplexSignal(childS, 3, 0);

6732
          ssSetDWorkUsedAsDState(childS, 3, 1);

6733
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 394))[0]);

6734
        }

6735


6736
        (childS)->regDataType.arg1 = ((void *)(childS));

6737
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

6738
          FcnSetErrorStatus);

6739
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

6740
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

6741
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

6742
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

6743


6744
        /* registration */

6745
#if defined(MATLAB_MEX_FILE)

6746


6747
        {

6748
          int_T i;

6749
          mxArray *plhs[1];

6750
          mxArray *prhs[4];

6751
          double *pr;

6752
          volatile int_T *intS = (int_T *)&childS;

6753
          int_T addrlen = sizeof(SimStruct *);

6754
          int_T m = addrlen/sizeof(int_T) + 1;

6755
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

6756
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

6757
          pr = mxGetPr(prhs[1]);

6758
          for (i = 0; i < m - 1; i++) {

6759
            pr[i] = (double)intS[i];

6760
          }

6761


6762
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

6763
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

6764
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

6765


6766
          /* Reset port dimensions info functions because the S-function

6767
           * and accelerator mex-files explicitly set their dimensions,

6768
           * i.e., they are not dynamically sized. For this case, the

6769
           * mex-file is responsible for the dimensions info memory

6770
           * and Simulink should not free it. This is achieved by

6771
           * setting the following two methods to NULL.

6772
           */

6773
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

6774
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

6775


6776
          /*

6777
           * Setup function pointers and call mdlInitializeSizes via

6778
           * simulink.c

6779
           */

6780
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

6781
          mxDestroyArray(plhs[0]);

6782
          mxDestroyArray(prhs[0]);

6783
          mxDestroyArray(prhs[1]);

6784
          mxDestroyArray(prhs[2]);

6785
          mxDestroyArray(prhs[3]);

6786
        }

6787


6788
#else

6789


6790
        {

6791
          LagFilter_sf(childS);

6792
          sfcnInitializeSizes(childS);

6793
        }

6794


6795
#endif

6796


6797
        sfcnInitializeSampleTimes(childS);

6798


6799
        /* adjust sample time */

6800
        ssSetSampleTime(childS, 0, 0.0);

6801
        ssSetOffsetTime(childS, 0, 0.0);

6802
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

6803


6804
        /* set compiled values of dynamic vector attributes */

6805
        ssSetNumNonsampledZCs(childS, 0);

6806


6807
        /* Update connectivity flags for each port */

6808
        _ssSetInputPortConnected(childS, 0, 1);

6809
        _ssSetInputPortConnected(childS, 1, 1);

6810
        _ssSetInputPortConnected(childS, 2, 1);

6811
        _ssSetInputPortConnected(childS, 3, 1);

6812
        _ssSetInputPortConnected(childS, 4, 1);

6813
        _ssSetInputPortConnected(childS, 5, 1);

6814
        _ssSetOutputPortConnected(childS, 0, 1);

6815
        _ssSetOutputPortBeingMerged(childS, 0, 0);

6816


6817
        /* Update the BufferDstPort flags for each input port */

6818
        _ssSetInputPortBufferDstPort(childS, 0, -1);

6819
        _ssSetInputPortBufferDstPort(childS, 1, -1);

6820
        _ssSetInputPortBufferDstPort(childS, 2, -1);

6821
        _ssSetInputPortBufferDstPort(childS, 3, -1);

6822
        _ssSetInputPortBufferDstPort(childS, 4, -1);

6823
        _ssSetInputPortBufferDstPort(childS, 5, -1);

6824
      }

6825


6826
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S114>/Generated S-Function (SaturationLimiter_sf) */

6827
      {

6828
        SimStruct *childS = ssGetSFunction(rts, 25);

6829


6830
        /* timing info */

6831
        time_T *sfcnPeriod;

6832
        time_T *sfcnOffset;

6833
        int_T *sfcnTsMap;

6834
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

6835
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

6836
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

6837
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

6838
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

6839
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

6840
        (void) memset((void*)sfcnPeriod, 0,

6841
                      sizeof(time_T)*1);

6842
        (void) memset((void*)sfcnOffset, 0,

6843
                      sizeof(time_T)*1);

6844
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

6845
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

6846
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

6847


6848
        /* Set up the mdlInfo pointer */

6849
# ifdef USE_RTMODEL

6850


6851
        {

6852
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

6853
              struct _ssBlkInfo2));

6854
          ss_VALIDATE_MEMORY(rts,blkInfo2);

6855
          ssSetBlkInfo2Ptr(childS, blkInfo2);

6856
        }

6857


6858
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

6859


6860
# else

6861


6862
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

6863


6864
# endif                                /* USE_RTMODEL */

6865


6866
        /* Allocate memory of model methods 2 */

6867
        {

6868
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

6869
            malloc(sizeof(struct _ssSFcnModelMethods2));

6870
          ss_VALIDATE_MEMORY(rts,methods2);

6871
          ssSetModelMethods2(childS, methods2);

6872
        }

6873


6874
        /* Allocate memory of model methods 3 */

6875
        {

6876
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

6877
            malloc(sizeof(struct _ssSFcnModelMethods3));

6878
          ss_VALIDATE_MEMORY(rts,methods3);

6879
          ssSetModelMethods3(childS, methods3);

6880
        }

6881


6882
        /* Allocate memory for states auxilliary information */

6883
        {

6884
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

6885
            (sizeof(struct _ssStatesInfo2));

6886
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

6887
            malloc(sizeof(ssPeriodicStatesInfo));

6888
          ss_VALIDATE_MEMORY(rts,statesInfo2);

6889
          ssSetStatesInfo2(childS, statesInfo2);

6890
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

6891
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

6892
        }

6893


6894
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

6895
          RegNumInputPorts);

6896
        ssSetRegNumInputPortsFcnArg(childS,childS);

6897


6898
        /* inputs */

6899
        {

6900
          struct _ssPortInputs *inputPortInfo =

6901
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

6902
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

6903
          _ssSetNumInputPorts(childS, 3);

6904
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

6905


6906
          /* port 0 */

6907
          {

6908
            real32_T const **sfcnUPtrs = (real32_T const **)

6909
              malloc(1 * sizeof(real32_T *));

6910
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6911
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

6912
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

6913
            _ssSetInputPortNumDimensions(childS, 0, 1);

6914
            ssSetInputPortWidth(childS, 0, 1);

6915
          }

6916


6917
          /* port 1 */

6918
          {

6919
            real32_T const **sfcnUPtrs = (real32_T const **)

6920
              malloc(1 * sizeof(real32_T *));

6921
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6922
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6923
              ssGetLocalBlockIO(rts))->Product1_m;

6924
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

6925
            _ssSetInputPortNumDimensions(childS, 1, 1);

6926
            ssSetInputPortWidth(childS, 1, 1);

6927
          }

6928


6929
          /* port 2 */

6930
          {

6931
            real32_T const **sfcnUPtrs = (real32_T const **)

6932
              malloc(1 * sizeof(real32_T *));

6933
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

6934
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

6935
              ssGetLocalBlockIO(rts))->Product_pp;

6936
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

6937
            _ssSetInputPortNumDimensions(childS, 2, 1);

6938
            ssSetInputPortWidth(childS, 2, 1);

6939
          }

6940
        }

6941


6942
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

6943
          RegNumOutputPorts);

6944
        ssSetRegNumOutputPortsFcnArg(childS,childS);

6945


6946
        /* outputs */

6947
        {

6948
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

6949
            calloc(1, sizeof(struct _ssPortOutputs));

6950
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

6951
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

6952
          _ssSetNumOutputPorts(childS, 1);

6953


6954
          /* port 0 */

6955
          {

6956
            _ssSetOutputPortNumDimensions(childS, 0, 1);

6957
            ssSetOutputPortWidth(childS, 0, 1);

6958
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

6959
              ssGetLocalBlockIO(rts))->GeneratedSFunction_kz));

6960
          }

6961
        }

6962


6963
        /* path info */

6964
        _ssSetModelName(childS, "SaturationLimiter_sf");

6965
        _ssSetPath(childS,

6966
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/NzControl/Saturation Limiter1/Generated S-Function");

6967
        if (ssGetRTModel(rts) == (NULL)) {

6968
          _ssSetParentSS(childS, rts);

6969
          _ssSetRootSS(childS, ssGetRootSS(rts));

6970
        } else {

6971
          ssSetRTModel(childS,ssGetRTModel(rts));

6972
          _ssSetParentSS(childS, (NULL));

6973
          _ssSetRootSS(childS, childS);

6974
        }

6975


6976
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

6977
        (childS)->regDataType.arg1 = ((void *)(childS));

6978
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

6979
          FcnSetErrorStatus);

6980
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

6981
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

6982
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

6983
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

6984


6985
        /* registration */

6986
#if defined(MATLAB_MEX_FILE)

6987


6988
        {

6989
          int_T i;

6990
          mxArray *plhs[1];

6991
          mxArray *prhs[4];

6992
          double *pr;

6993
          volatile int_T *intS = (int_T *)&childS;

6994
          int_T addrlen = sizeof(SimStruct *);

6995
          int_T m = addrlen/sizeof(int_T) + 1;

6996
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

6997
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

6998
          pr = mxGetPr(prhs[1]);

6999
          for (i = 0; i < m - 1; i++) {

7000
            pr[i] = (double)intS[i];

7001
          }

7002


7003
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

7004
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

7005
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

7006


7007
          /* Reset port dimensions info functions because the S-function

7008
           * and accelerator mex-files explicitly set their dimensions,

7009
           * i.e., they are not dynamically sized. For this case, the

7010
           * mex-file is responsible for the dimensions info memory

7011
           * and Simulink should not free it. This is achieved by

7012
           * setting the following two methods to NULL.

7013
           */

7014
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

7015
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

7016


7017
          /*

7018
           * Setup function pointers and call mdlInitializeSizes via

7019
           * simulink.c

7020
           */

7021
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

7022
          mxDestroyArray(plhs[0]);

7023
          mxDestroyArray(prhs[0]);

7024
          mxDestroyArray(prhs[1]);

7025
          mxDestroyArray(prhs[2]);

7026
          mxDestroyArray(prhs[3]);

7027
        }

7028


7029
#else

7030


7031
        {

7032
          SaturationLimiter_sf(childS);

7033
          sfcnInitializeSizes(childS);

7034
        }

7035


7036
#endif

7037


7038
        sfcnInitializeSampleTimes(childS);

7039


7040
        /* adjust sample time */

7041
        ssSetSampleTime(childS, 0, 0.0);

7042
        ssSetOffsetTime(childS, 0, 0.0);

7043
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

7044


7045
        /* set compiled values of dynamic vector attributes */

7046
        ssSetNumNonsampledZCs(childS, 0);

7047


7048
        /* Update connectivity flags for each port */

7049
        _ssSetInputPortConnected(childS, 0, 1);

7050
        _ssSetInputPortConnected(childS, 1, 1);

7051
        _ssSetInputPortConnected(childS, 2, 1);

7052
        _ssSetOutputPortConnected(childS, 0, 1);

7053
        _ssSetOutputPortBeingMerged(childS, 0, 0);

7054


7055
        /* Update the BufferDstPort flags for each input port */

7056
        _ssSetInputPortBufferDstPort(childS, 0, -1);

7057
        _ssSetInputPortBufferDstPort(childS, 1, -1);

7058
        _ssSetInputPortBufferDstPort(childS, 2, -1);

7059
      }

7060


7061
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S113>/Generated S-Function (LagFilter_sf) */

7062
      {

7063
        SimStruct *childS = ssGetSFunction(rts, 26);

7064


7065
        /* timing info */

7066
        time_T *sfcnPeriod;

7067
        time_T *sfcnOffset;

7068
        int_T *sfcnTsMap;

7069
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

7070
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

7071
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

7072
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

7073
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

7074
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

7075
        (void) memset((void*)sfcnPeriod, 0,

7076
                      sizeof(time_T)*1);

7077
        (void) memset((void*)sfcnOffset, 0,

7078
                      sizeof(time_T)*1);

7079
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

7080
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

7081
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

7082


7083
        /* Set up the mdlInfo pointer */

7084
# ifdef USE_RTMODEL

7085


7086
        {

7087
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

7088
              struct _ssBlkInfo2));

7089
          ss_VALIDATE_MEMORY(rts,blkInfo2);

7090
          ssSetBlkInfo2Ptr(childS, blkInfo2);

7091
        }

7092


7093
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

7094


7095
# else

7096


7097
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

7098


7099
# endif                                /* USE_RTMODEL */

7100


7101
        /* Allocate memory of model methods 2 */

7102
        {

7103
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

7104
            malloc(sizeof(struct _ssSFcnModelMethods2));

7105
          ss_VALIDATE_MEMORY(rts,methods2);

7106
          ssSetModelMethods2(childS, methods2);

7107
        }

7108


7109
        /* Allocate memory of model methods 3 */

7110
        {

7111
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

7112
            malloc(sizeof(struct _ssSFcnModelMethods3));

7113
          ss_VALIDATE_MEMORY(rts,methods3);

7114
          ssSetModelMethods3(childS, methods3);

7115
        }

7116


7117
        /* Allocate memory for states auxilliary information */

7118
        {

7119
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

7120
            (sizeof(struct _ssStatesInfo2));

7121
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

7122
            malloc(sizeof(ssPeriodicStatesInfo));

7123
          ss_VALIDATE_MEMORY(rts,statesInfo2);

7124
          ssSetStatesInfo2(childS, statesInfo2);

7125
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

7126
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

7127
        }

7128


7129
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

7130
          RegNumInputPorts);

7131
        ssSetRegNumInputPortsFcnArg(childS,childS);

7132


7133
        /* inputs */

7134
        {

7135
          struct _ssPortInputs *inputPortInfo =

7136
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

7137
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

7138
          _ssSetNumInputPorts(childS, 6);

7139
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

7140


7141
          /* port 0 */

7142
          {

7143
            real32_T const **sfcnUPtrs = (real32_T const **)

7144
              malloc(1 * sizeof(real32_T *));

7145
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7146
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

7147
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

7148
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

7149
            _ssSetInputPortNumDimensions(childS, 0, 1);

7150
            ssSetInputPortWidth(childS, 0, 1);

7151
          }

7152


7153
          /* port 1 */

7154
          {

7155
            int8_T const **sfcnUPtrs = (int8_T const **)

7156
              malloc(1 * sizeof(int8_T *));

7157
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7158
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

7159
              ssGetLocalBlockIO(rts))->DataTypeConversion_gv;

7160
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

7161
            _ssSetInputPortNumDimensions(childS, 1, 1);

7162
            ssSetInputPortWidth(childS, 1, 1);

7163
          }

7164


7165
          /* port 2 */

7166
          {

7167
            real32_T const **sfcnUPtrs = (real32_T const **)

7168
              malloc(1 * sizeof(real32_T *));

7169
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7170
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

7171
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

7172
            _ssSetInputPortNumDimensions(childS, 2, 1);

7173
            ssSetInputPortWidth(childS, 2, 1);

7174
          }

7175


7176
          /* port 3 */

7177
          {

7178
            real32_T const **sfcnUPtrs = (real32_T const **)

7179
              malloc(1 * sizeof(real32_T *));

7180
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7181
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

7182
              ssGetLocalBlockIO(rts))->Switch_aj;

7183
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

7184
            _ssSetInputPortNumDimensions(childS, 3, 1);

7185
            ssSetInputPortWidth(childS, 3, 1);

7186
          }

7187


7188
          /* port 4 */

7189
          {

7190
            real32_T const **sfcnUPtrs = (real32_T const **)

7191
              malloc(1 * sizeof(real32_T *));

7192
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7193
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

7194
              ssGetLocalBlockIO(rts))->Switch_aj;

7195
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

7196
            _ssSetInputPortNumDimensions(childS, 4, 1);

7197
            ssSetInputPortWidth(childS, 4, 1);

7198
          }

7199


7200
          /* port 5 */

7201
          {

7202
            real32_T const **sfcnUPtrs = (real32_T const **)

7203
              malloc(1 * sizeof(real32_T *));

7204
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7205
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

7206
              ssGetLocalBlockIO(rts))->GeneratedSFunction_kz;

7207
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

7208
            _ssSetInputPortNumDimensions(childS, 5, 1);

7209
            ssSetInputPortWidth(childS, 5, 1);

7210
          }

7211
        }

7212


7213
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

7214
          RegNumOutputPorts);

7215
        ssSetRegNumOutputPortsFcnArg(childS,childS);

7216


7217
        /* outputs */

7218
        {

7219
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

7220
            calloc(1, sizeof(struct _ssPortOutputs));

7221
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

7222
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

7223
          _ssSetNumOutputPorts(childS, 1);

7224


7225
          /* port 0 */

7226
          {

7227
            _ssSetOutputPortNumDimensions(childS, 0, 1);

7228
            ssSetOutputPortWidth(childS, 0, 1);

7229
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

7230
              ssGetLocalBlockIO(rts))->GeneratedSFunction_p));

7231
          }

7232
        }

7233


7234
        /* path info */

7235
        _ssSetModelName(childS, "LagFilter_sf");

7236
        _ssSetPath(childS,

7237
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/NzControl/ lag filter/Generated S-Function");

7238
        if (ssGetRTModel(rts) == (NULL)) {

7239
          _ssSetParentSS(childS, rts);

7240
          _ssSetRootSS(childS, ssGetRootSS(rts));

7241
        } else {

7242
          ssSetRTModel(childS,ssGetRTModel(rts));

7243
          _ssSetParentSS(childS, (NULL));

7244
          _ssSetRootSS(childS, childS);

7245
        }

7246


7247
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

7248


7249
        /* work vectors */

7250
        {

7251
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

7252
            (4 * sizeof(struct _ssDWorkRecord));

7253
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

7254
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

7255
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

7256
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

7257
          ssSetSFcnDWork(childS, dWorkRecord);

7258
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

7259
          _ssSetNumDWork(childS, 4);

7260


7261
          /* DWORK0 */

7262
          ssSetDWorkWidth(childS, 0, 1);

7263
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

7264
          ssSetDWorkComplexSignal(childS, 0, 0);

7265
          ssSetDWorkUsedAsDState(childS, 0, 1);

7266
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 168))[0]);

7267


7268
          /* DWORK1 */

7269
          ssSetDWorkWidth(childS, 1, 1);

7270
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

7271
          ssSetDWorkComplexSignal(childS, 1, 0);

7272
          ssSetDWorkUsedAsDState(childS, 1, 1);

7273
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 169))[0]);

7274


7275
          /* DWORK2 */

7276
          ssSetDWorkWidth(childS, 2, 1);

7277
          ssSetDWorkDataType(childS, 2,SS_INT8);

7278
          ssSetDWorkComplexSignal(childS, 2, 0);

7279
          ssSetDWorkUsedAsDState(childS, 2, 1);

7280
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 395))[0]);

7281


7282
          /* DWORK3 */

7283
          ssSetDWorkWidth(childS, 3, 1);

7284
          ssSetDWorkDataType(childS, 3,SS_INT8);

7285
          ssSetDWorkComplexSignal(childS, 3, 0);

7286
          ssSetDWorkUsedAsDState(childS, 3, 1);

7287
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 396))[0]);

7288
        }

7289


7290
        (childS)->regDataType.arg1 = ((void *)(childS));

7291
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

7292
          FcnSetErrorStatus);

7293
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

7294
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

7295
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

7296
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

7297


7298
        /* registration */

7299
#if defined(MATLAB_MEX_FILE)

7300


7301
        {

7302
          int_T i;

7303
          mxArray *plhs[1];

7304
          mxArray *prhs[4];

7305
          double *pr;

7306
          volatile int_T *intS = (int_T *)&childS;

7307
          int_T addrlen = sizeof(SimStruct *);

7308
          int_T m = addrlen/sizeof(int_T) + 1;

7309
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

7310
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

7311
          pr = mxGetPr(prhs[1]);

7312
          for (i = 0; i < m - 1; i++) {

7313
            pr[i] = (double)intS[i];

7314
          }

7315


7316
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

7317
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

7318
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

7319


7320
          /* Reset port dimensions info functions because the S-function

7321
           * and accelerator mex-files explicitly set their dimensions,

7322
           * i.e., they are not dynamically sized. For this case, the

7323
           * mex-file is responsible for the dimensions info memory

7324
           * and Simulink should not free it. This is achieved by

7325
           * setting the following two methods to NULL.

7326
           */

7327
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

7328
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

7329


7330
          /*

7331
           * Setup function pointers and call mdlInitializeSizes via

7332
           * simulink.c

7333
           */

7334
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

7335
          mxDestroyArray(plhs[0]);

7336
          mxDestroyArray(prhs[0]);

7337
          mxDestroyArray(prhs[1]);

7338
          mxDestroyArray(prhs[2]);

7339
          mxDestroyArray(prhs[3]);

7340
        }

7341


7342
#else

7343


7344
        {

7345
          LagFilter_sf(childS);

7346
          sfcnInitializeSizes(childS);

7347
        }

7348


7349
#endif

7350


7351
        sfcnInitializeSampleTimes(childS);

7352


7353
        /* adjust sample time */

7354
        ssSetSampleTime(childS, 0, 0.0);

7355
        ssSetOffsetTime(childS, 0, 0.0);

7356
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

7357


7358
        /* set compiled values of dynamic vector attributes */

7359
        ssSetNumNonsampledZCs(childS, 0);

7360


7361
        /* Update connectivity flags for each port */

7362
        _ssSetInputPortConnected(childS, 0, 1);

7363
        _ssSetInputPortConnected(childS, 1, 1);

7364
        _ssSetInputPortConnected(childS, 2, 1);

7365
        _ssSetInputPortConnected(childS, 3, 1);

7366
        _ssSetInputPortConnected(childS, 4, 1);

7367
        _ssSetInputPortConnected(childS, 5, 1);

7368
        _ssSetOutputPortConnected(childS, 0, 1);

7369
        _ssSetOutputPortBeingMerged(childS, 0, 0);

7370


7371
        /* Update the BufferDstPort flags for each input port */

7372
        _ssSetInputPortBufferDstPort(childS, 0, -1);

7373
        _ssSetInputPortBufferDstPort(childS, 1, -1);

7374
        _ssSetInputPortBufferDstPort(childS, 2, -1);

7375
        _ssSetInputPortBufferDstPort(childS, 3, -1);

7376
        _ssSetInputPortBufferDstPort(childS, 4, -1);

7377
        _ssSetInputPortBufferDstPort(childS, 5, -1);

7378
      }

7379


7380
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S86>/Generated S-Function6 (Res180_sf) */

7381
      {

7382
        SimStruct *childS = ssGetSFunction(rts, 27);

7383


7384
        /* timing info */

7385
        time_T *sfcnPeriod;

7386
        time_T *sfcnOffset;

7387
        int_T *sfcnTsMap;

7388
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

7389
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

7390
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

7391
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

7392
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

7393
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

7394
        (void) memset((void*)sfcnPeriod, 0,

7395
                      sizeof(time_T)*1);

7396
        (void) memset((void*)sfcnOffset, 0,

7397
                      sizeof(time_T)*1);

7398
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

7399
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

7400
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

7401


7402
        /* Set up the mdlInfo pointer */

7403
# ifdef USE_RTMODEL

7404


7405
        {

7406
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

7407
              struct _ssBlkInfo2));

7408
          ss_VALIDATE_MEMORY(rts,blkInfo2);

7409
          ssSetBlkInfo2Ptr(childS, blkInfo2);

7410
        }

7411


7412
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

7413


7414
# else

7415


7416
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

7417


7418
# endif                                /* USE_RTMODEL */

7419


7420
        /* Allocate memory of model methods 2 */

7421
        {

7422
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

7423
            malloc(sizeof(struct _ssSFcnModelMethods2));

7424
          ss_VALIDATE_MEMORY(rts,methods2);

7425
          ssSetModelMethods2(childS, methods2);

7426
        }

7427


7428
        /* Allocate memory of model methods 3 */

7429
        {

7430
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

7431
            malloc(sizeof(struct _ssSFcnModelMethods3));

7432
          ss_VALIDATE_MEMORY(rts,methods3);

7433
          ssSetModelMethods3(childS, methods3);

7434
        }

7435


7436
        /* Allocate memory for states auxilliary information */

7437
        {

7438
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

7439
            (sizeof(struct _ssStatesInfo2));

7440
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

7441
            malloc(sizeof(ssPeriodicStatesInfo));

7442
          ss_VALIDATE_MEMORY(rts,statesInfo2);

7443
          ssSetStatesInfo2(childS, statesInfo2);

7444
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

7445
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

7446
        }

7447


7448
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

7449
          RegNumInputPorts);

7450
        ssSetRegNumInputPortsFcnArg(childS,childS);

7451


7452
        /* inputs */

7453
        {

7454
          struct _ssPortInputs *inputPortInfo =

7455
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

7456
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

7457
          _ssSetNumInputPorts(childS, 1);

7458
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

7459


7460
          /* port 0 */

7461
          {

7462
            real32_T const **sfcnUPtrs = (real32_T const **)

7463
              malloc(1 * sizeof(real32_T *));

7464
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7465
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

7466
              ssGetLocalBlockIO(rts))->Sum1_f;

7467
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

7468
            _ssSetInputPortNumDimensions(childS, 0, 1);

7469
            ssSetInputPortWidth(childS, 0, 1);

7470
          }

7471
        }

7472


7473
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

7474
          RegNumOutputPorts);

7475
        ssSetRegNumOutputPortsFcnArg(childS,childS);

7476


7477
        /* outputs */

7478
        {

7479
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

7480
            calloc(1, sizeof(struct _ssPortOutputs));

7481
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

7482
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

7483
          _ssSetNumOutputPorts(childS, 1);

7484


7485
          /* port 0 */

7486
          {

7487
            _ssSetOutputPortNumDimensions(childS, 0, 1);

7488
            ssSetOutputPortWidth(childS, 0, 1);

7489
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

7490
              ssGetLocalBlockIO(rts))->GeneratedSFunction6));

7491
          }

7492
        }

7493


7494
        /* path info */

7495
        _ssSetModelName(childS, "Res180_sf");

7496
        _ssSetPath(childS,

7497
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Generated S-Function6");

7498
        if (ssGetRTModel(rts) == (NULL)) {

7499
          _ssSetParentSS(childS, rts);

7500
          _ssSetRootSS(childS, ssGetRootSS(rts));

7501
        } else {

7502
          ssSetRTModel(childS,ssGetRTModel(rts));

7503
          _ssSetParentSS(childS, (NULL));

7504
          _ssSetRootSS(childS, childS);

7505
        }

7506


7507
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

7508
        (childS)->regDataType.arg1 = ((void *)(childS));

7509
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

7510
          FcnSetErrorStatus);

7511
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

7512
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

7513
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

7514
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

7515


7516
        /* registration */

7517
#if defined(MATLAB_MEX_FILE)

7518


7519
        {

7520
          int_T i;

7521
          mxArray *plhs[1];

7522
          mxArray *prhs[4];

7523
          double *pr;

7524
          volatile int_T *intS = (int_T *)&childS;

7525
          int_T addrlen = sizeof(SimStruct *);

7526
          int_T m = addrlen/sizeof(int_T) + 1;

7527
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

7528
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

7529
          pr = mxGetPr(prhs[1]);

7530
          for (i = 0; i < m - 1; i++) {

7531
            pr[i] = (double)intS[i];

7532
          }

7533


7534
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

7535
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

7536
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

7537


7538
          /* Reset port dimensions info functions because the S-function

7539
           * and accelerator mex-files explicitly set their dimensions,

7540
           * i.e., they are not dynamically sized. For this case, the

7541
           * mex-file is responsible for the dimensions info memory

7542
           * and Simulink should not free it. This is achieved by

7543
           * setting the following two methods to NULL.

7544
           */

7545
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

7546
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

7547


7548
          /*

7549
           * Setup function pointers and call mdlInitializeSizes via

7550
           * simulink.c

7551
           */

7552
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

7553
          mxDestroyArray(plhs[0]);

7554
          mxDestroyArray(prhs[0]);

7555
          mxDestroyArray(prhs[1]);

7556
          mxDestroyArray(prhs[2]);

7557
          mxDestroyArray(prhs[3]);

7558
        }

7559


7560
#else

7561


7562
        {

7563
          Res180_sf(childS);

7564
          sfcnInitializeSizes(childS);

7565
        }

7566


7567
#endif

7568


7569
        sfcnInitializeSampleTimes(childS);

7570


7571
        /* adjust sample time */

7572
        ssSetSampleTime(childS, 0, 0.0);

7573
        ssSetOffsetTime(childS, 0, 0.0);

7574
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

7575


7576
        /* set compiled values of dynamic vector attributes */

7577
        ssSetNumNonsampledZCs(childS, 0);

7578


7579
        /* Update connectivity flags for each port */

7580
        _ssSetInputPortConnected(childS, 0, 1);

7581
        _ssSetOutputPortConnected(childS, 0, 1);

7582
        _ssSetOutputPortBeingMerged(childS, 0, 0);

7583


7584
        /* Update the BufferDstPort flags for each input port */

7585
        _ssSetInputPortBufferDstPort(childS, 0, -1);

7586
      }

7587


7588
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S119>/Generated S-Function (SaturationLimiter_sf) */

7589
      {

7590
        SimStruct *childS = ssGetSFunction(rts, 28);

7591


7592
        /* timing info */

7593
        time_T *sfcnPeriod;

7594
        time_T *sfcnOffset;

7595
        int_T *sfcnTsMap;

7596
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

7597
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

7598
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

7599
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

7600
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

7601
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

7602
        (void) memset((void*)sfcnPeriod, 0,

7603
                      sizeof(time_T)*1);

7604
        (void) memset((void*)sfcnOffset, 0,

7605
                      sizeof(time_T)*1);

7606
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

7607
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

7608
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

7609


7610
        /* Set up the mdlInfo pointer */

7611
# ifdef USE_RTMODEL

7612


7613
        {

7614
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

7615
              struct _ssBlkInfo2));

7616
          ss_VALIDATE_MEMORY(rts,blkInfo2);

7617
          ssSetBlkInfo2Ptr(childS, blkInfo2);

7618
        }

7619


7620
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

7621


7622
# else

7623


7624
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

7625


7626
# endif                                /* USE_RTMODEL */

7627


7628
        /* Allocate memory of model methods 2 */

7629
        {

7630
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

7631
            malloc(sizeof(struct _ssSFcnModelMethods2));

7632
          ss_VALIDATE_MEMORY(rts,methods2);

7633
          ssSetModelMethods2(childS, methods2);

7634
        }

7635


7636
        /* Allocate memory of model methods 3 */

7637
        {

7638
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

7639
            malloc(sizeof(struct _ssSFcnModelMethods3));

7640
          ss_VALIDATE_MEMORY(rts,methods3);

7641
          ssSetModelMethods3(childS, methods3);

7642
        }

7643


7644
        /* Allocate memory for states auxilliary information */

7645
        {

7646
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

7647
            (sizeof(struct _ssStatesInfo2));

7648
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

7649
            malloc(sizeof(ssPeriodicStatesInfo));

7650
          ss_VALIDATE_MEMORY(rts,statesInfo2);

7651
          ssSetStatesInfo2(childS, statesInfo2);

7652
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

7653
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

7654
        }

7655


7656
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

7657
          RegNumInputPorts);

7658
        ssSetRegNumInputPortsFcnArg(childS,childS);

7659


7660
        /* inputs */

7661
        {

7662
          struct _ssPortInputs *inputPortInfo =

7663
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

7664
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

7665
          _ssSetNumInputPorts(childS, 3);

7666
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

7667


7668
          /* port 0 */

7669
          {

7670
            real32_T const **sfcnUPtrs = (real32_T const **)

7671
              malloc(1 * sizeof(real32_T *));

7672
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7673
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

7674
              ssGetLocalBlockIO(rts))->GeneratedSFunction6;

7675
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

7676
            _ssSetInputPortNumDimensions(childS, 0, 1);

7677
            ssSetInputPortWidth(childS, 0, 1);

7678
          }

7679


7680
          /* port 1 */

7681
          {

7682
            real32_T const **sfcnUPtrs = (real32_T const **)

7683
              malloc(1 * sizeof(real32_T *));

7684
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7685
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

7686
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

7687
            _ssSetInputPortNumDimensions(childS, 1, 1);

7688
            ssSetInputPortWidth(childS, 1, 1);

7689
          }

7690


7691
          /* port 2 */

7692
          {

7693
            real32_T const **sfcnUPtrs = (real32_T const **)

7694
              malloc(1 * sizeof(real32_T *));

7695
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7696
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;

7697
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

7698
            _ssSetInputPortNumDimensions(childS, 2, 1);

7699
            ssSetInputPortWidth(childS, 2, 1);

7700
          }

7701
        }

7702


7703
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

7704
          RegNumOutputPorts);

7705
        ssSetRegNumOutputPortsFcnArg(childS,childS);

7706


7707
        /* outputs */

7708
        {

7709
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

7710
            calloc(1, sizeof(struct _ssPortOutputs));

7711
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

7712
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

7713
          _ssSetNumOutputPorts(childS, 1);

7714


7715
          /* port 0 */

7716
          {

7717
            _ssSetOutputPortNumDimensions(childS, 0, 1);

7718
            ssSetOutputPortWidth(childS, 0, 1);

7719
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

7720
              ssGetLocalBlockIO(rts))->GeneratedSFunction_n0));

7721
          }

7722
        }

7723


7724
        /* path info */

7725
        _ssSetModelName(childS, "SaturationLimiter_sf");

7726
        _ssSetPath(childS,

7727
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Saturation Limiter/Generated S-Function");

7728
        if (ssGetRTModel(rts) == (NULL)) {

7729
          _ssSetParentSS(childS, rts);

7730
          _ssSetRootSS(childS, ssGetRootSS(rts));

7731
        } else {

7732
          ssSetRTModel(childS,ssGetRTModel(rts));

7733
          _ssSetParentSS(childS, (NULL));

7734
          _ssSetRootSS(childS, childS);

7735
        }

7736


7737
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

7738
        (childS)->regDataType.arg1 = ((void *)(childS));

7739
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

7740
          FcnSetErrorStatus);

7741
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

7742
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

7743
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

7744
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

7745


7746
        /* registration */

7747
#if defined(MATLAB_MEX_FILE)

7748


7749
        {

7750
          int_T i;

7751
          mxArray *plhs[1];

7752
          mxArray *prhs[4];

7753
          double *pr;

7754
          volatile int_T *intS = (int_T *)&childS;

7755
          int_T addrlen = sizeof(SimStruct *);

7756
          int_T m = addrlen/sizeof(int_T) + 1;

7757
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

7758
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

7759
          pr = mxGetPr(prhs[1]);

7760
          for (i = 0; i < m - 1; i++) {

7761
            pr[i] = (double)intS[i];

7762
          }

7763


7764
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

7765
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

7766
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

7767


7768
          /* Reset port dimensions info functions because the S-function

7769
           * and accelerator mex-files explicitly set their dimensions,

7770
           * i.e., they are not dynamically sized. For this case, the

7771
           * mex-file is responsible for the dimensions info memory

7772
           * and Simulink should not free it. This is achieved by

7773
           * setting the following two methods to NULL.

7774
           */

7775
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

7776
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

7777


7778
          /*

7779
           * Setup function pointers and call mdlInitializeSizes via

7780
           * simulink.c

7781
           */

7782
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

7783
          mxDestroyArray(plhs[0]);

7784
          mxDestroyArray(prhs[0]);

7785
          mxDestroyArray(prhs[1]);

7786
          mxDestroyArray(prhs[2]);

7787
          mxDestroyArray(prhs[3]);

7788
        }

7789


7790
#else

7791


7792
        {

7793
          SaturationLimiter_sf(childS);

7794
          sfcnInitializeSizes(childS);

7795
        }

7796


7797
#endif

7798


7799
        sfcnInitializeSampleTimes(childS);

7800


7801
        /* adjust sample time */

7802
        ssSetSampleTime(childS, 0, 0.0);

7803
        ssSetOffsetTime(childS, 0, 0.0);

7804
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

7805


7806
        /* set compiled values of dynamic vector attributes */

7807
        ssSetNumNonsampledZCs(childS, 0);

7808


7809
        /* Update connectivity flags for each port */

7810
        _ssSetInputPortConnected(childS, 0, 1);

7811
        _ssSetInputPortConnected(childS, 1, 1);

7812
        _ssSetInputPortConnected(childS, 2, 1);

7813
        _ssSetOutputPortConnected(childS, 0, 1);

7814
        _ssSetOutputPortBeingMerged(childS, 0, 0);

7815


7816
        /* Update the BufferDstPort flags for each input port */

7817
        _ssSetInputPortBufferDstPort(childS, 0, -1);

7818
        _ssSetInputPortBufferDstPort(childS, 1, -1);

7819
        _ssSetInputPortBufferDstPort(childS, 2, -1);

7820
      }

7821


7822
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S121>/Generated S-Function (Gain_sf) */

7823
      {

7824
        SimStruct *childS = ssGetSFunction(rts, 29);

7825


7826
        /* timing info */

7827
        time_T *sfcnPeriod;

7828
        time_T *sfcnOffset;

7829
        int_T *sfcnTsMap;

7830
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

7831
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

7832
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

7833
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

7834
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

7835
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

7836
        (void) memset((void*)sfcnPeriod, 0,

7837
                      sizeof(time_T)*1);

7838
        (void) memset((void*)sfcnOffset, 0,

7839
                      sizeof(time_T)*1);

7840
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

7841
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

7842
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

7843


7844
        /* Set up the mdlInfo pointer */

7845
# ifdef USE_RTMODEL

7846


7847
        {

7848
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

7849
              struct _ssBlkInfo2));

7850
          ss_VALIDATE_MEMORY(rts,blkInfo2);

7851
          ssSetBlkInfo2Ptr(childS, blkInfo2);

7852
        }

7853


7854
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

7855


7856
# else

7857


7858
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

7859


7860
# endif                                /* USE_RTMODEL */

7861


7862
        /* Allocate memory of model methods 2 */

7863
        {

7864
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

7865
            malloc(sizeof(struct _ssSFcnModelMethods2));

7866
          ss_VALIDATE_MEMORY(rts,methods2);

7867
          ssSetModelMethods2(childS, methods2);

7868
        }

7869


7870
        /* Allocate memory of model methods 3 */

7871
        {

7872
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

7873
            malloc(sizeof(struct _ssSFcnModelMethods3));

7874
          ss_VALIDATE_MEMORY(rts,methods3);

7875
          ssSetModelMethods3(childS, methods3);

7876
        }

7877


7878
        /* Allocate memory for states auxilliary information */

7879
        {

7880
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

7881
            (sizeof(struct _ssStatesInfo2));

7882
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

7883
            malloc(sizeof(ssPeriodicStatesInfo));

7884
          ss_VALIDATE_MEMORY(rts,statesInfo2);

7885
          ssSetStatesInfo2(childS, statesInfo2);

7886
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

7887
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

7888
        }

7889


7890
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

7891
          RegNumInputPorts);

7892
        ssSetRegNumInputPortsFcnArg(childS,childS);

7893


7894
        /* inputs */

7895
        {

7896
          struct _ssPortInputs *inputPortInfo =

7897
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

7898
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

7899
          _ssSetNumInputPorts(childS, 2);

7900
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

7901


7902
          /* port 0 */

7903
          {

7904
            real32_T const **sfcnUPtrs = (real32_T const **)

7905
              malloc(1 * sizeof(real32_T *));

7906
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7907
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

7908
              ssGetLocalBlockIO(rts))->GeneratedSFunction_n0;

7909
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

7910
            _ssSetInputPortNumDimensions(childS, 0, 1);

7911
            ssSetInputPortWidth(childS, 0, 1);

7912
          }

7913


7914
          /* port 1 */

7915
          {

7916
            real32_T const **sfcnUPtrs = (real32_T const **)

7917
              malloc(1 * sizeof(real32_T *));

7918
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

7919
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;

7920
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

7921
            _ssSetInputPortNumDimensions(childS, 1, 1);

7922
            ssSetInputPortWidth(childS, 1, 1);

7923
          }

7924
        }

7925


7926
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

7927
          RegNumOutputPorts);

7928
        ssSetRegNumOutputPortsFcnArg(childS,childS);

7929


7930
        /* outputs */

7931
        {

7932
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

7933
            calloc(1, sizeof(struct _ssPortOutputs));

7934
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

7935
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

7936
          _ssSetNumOutputPorts(childS, 1);

7937


7938
          /* port 0 */

7939
          {

7940
            _ssSetOutputPortNumDimensions(childS, 0, 1);

7941
            ssSetOutputPortWidth(childS, 0, 1);

7942
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

7943
              ssGetLocalBlockIO(rts))->GeneratedSFunction_k1));

7944
          }

7945
        }

7946


7947
        /* path info */

7948
        _ssSetModelName(childS, "Gain_sf");

7949
        _ssSetPath(childS,

7950
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/gain/Generated S-Function");

7951
        if (ssGetRTModel(rts) == (NULL)) {

7952
          _ssSetParentSS(childS, rts);

7953
          _ssSetRootSS(childS, ssGetRootSS(rts));

7954
        } else {

7955
          ssSetRTModel(childS,ssGetRTModel(rts));

7956
          _ssSetParentSS(childS, (NULL));

7957
          _ssSetRootSS(childS, childS);

7958
        }

7959


7960
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

7961
        (childS)->regDataType.arg1 = ((void *)(childS));

7962
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

7963
          FcnSetErrorStatus);

7964
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

7965
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

7966
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

7967
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

7968


7969
        /* registration */

7970
#if defined(MATLAB_MEX_FILE)

7971


7972
        {

7973
          int_T i;

7974
          mxArray *plhs[1];

7975
          mxArray *prhs[4];

7976
          double *pr;

7977
          volatile int_T *intS = (int_T *)&childS;

7978
          int_T addrlen = sizeof(SimStruct *);

7979
          int_T m = addrlen/sizeof(int_T) + 1;

7980
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

7981
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

7982
          pr = mxGetPr(prhs[1]);

7983
          for (i = 0; i < m - 1; i++) {

7984
            pr[i] = (double)intS[i];

7985
          }

7986


7987
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

7988
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

7989
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

7990


7991
          /* Reset port dimensions info functions because the S-function

7992
           * and accelerator mex-files explicitly set their dimensions,

7993
           * i.e., they are not dynamically sized. For this case, the

7994
           * mex-file is responsible for the dimensions info memory

7995
           * and Simulink should not free it. This is achieved by

7996
           * setting the following two methods to NULL.

7997
           */

7998
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

7999
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

8000


8001
          /*

8002
           * Setup function pointers and call mdlInitializeSizes via

8003
           * simulink.c

8004
           */

8005
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

8006
          mxDestroyArray(plhs[0]);

8007
          mxDestroyArray(prhs[0]);

8008
          mxDestroyArray(prhs[1]);

8009
          mxDestroyArray(prhs[2]);

8010
          mxDestroyArray(prhs[3]);

8011
        }

8012


8013
#else

8014


8015
        {

8016
          Gain_sf(childS);

8017
          sfcnInitializeSizes(childS);

8018
        }

8019


8020
#endif

8021


8022
        sfcnInitializeSampleTimes(childS);

8023


8024
        /* adjust sample time */

8025
        ssSetSampleTime(childS, 0, 0.0);

8026
        ssSetOffsetTime(childS, 0, 0.0);

8027
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

8028


8029
        /* set compiled values of dynamic vector attributes */

8030
        ssSetNumNonsampledZCs(childS, 0);

8031


8032
        /* Update connectivity flags for each port */

8033
        _ssSetInputPortConnected(childS, 0, 1);

8034
        _ssSetInputPortConnected(childS, 1, 1);

8035
        _ssSetOutputPortConnected(childS, 0, 1);

8036
        _ssSetOutputPortBeingMerged(childS, 0, 0);

8037


8038
        /* Update the BufferDstPort flags for each input port */

8039
        _ssSetInputPortBufferDstPort(childS, 0, -1);

8040
        _ssSetInputPortBufferDstPort(childS, 1, -1);

8041
      }

8042


8043
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S118>/Generated S-Function2 (LeadLagFilter_sf) */

8044
      {

8045
        SimStruct *childS = ssGetSFunction(rts, 30);

8046


8047
        /* timing info */

8048
        time_T *sfcnPeriod;

8049
        time_T *sfcnOffset;

8050
        int_T *sfcnTsMap;

8051
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

8052
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

8053
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

8054
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

8055
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

8056
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

8057
        (void) memset((void*)sfcnPeriod, 0,

8058
                      sizeof(time_T)*1);

8059
        (void) memset((void*)sfcnOffset, 0,

8060
                      sizeof(time_T)*1);

8061
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

8062
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

8063
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

8064


8065
        /* Set up the mdlInfo pointer */

8066
# ifdef USE_RTMODEL

8067


8068
        {

8069
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

8070
              struct _ssBlkInfo2));

8071
          ss_VALIDATE_MEMORY(rts,blkInfo2);

8072
          ssSetBlkInfo2Ptr(childS, blkInfo2);

8073
        }

8074


8075
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

8076


8077
# else

8078


8079
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

8080


8081
# endif                                /* USE_RTMODEL */

8082


8083
        /* Allocate memory of model methods 2 */

8084
        {

8085
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

8086
            malloc(sizeof(struct _ssSFcnModelMethods2));

8087
          ss_VALIDATE_MEMORY(rts,methods2);

8088
          ssSetModelMethods2(childS, methods2);

8089
        }

8090


8091
        /* Allocate memory of model methods 3 */

8092
        {

8093
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

8094
            malloc(sizeof(struct _ssSFcnModelMethods3));

8095
          ss_VALIDATE_MEMORY(rts,methods3);

8096
          ssSetModelMethods3(childS, methods3);

8097
        }

8098


8099
        /* Allocate memory for states auxilliary information */

8100
        {

8101
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

8102
            (sizeof(struct _ssStatesInfo2));

8103
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

8104
            malloc(sizeof(ssPeriodicStatesInfo));

8105
          ss_VALIDATE_MEMORY(rts,statesInfo2);

8106
          ssSetStatesInfo2(childS, statesInfo2);

8107
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

8108
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

8109
        }

8110


8111
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

8112
          RegNumInputPorts);

8113
        ssSetRegNumInputPortsFcnArg(childS,childS);

8114


8115
        /* inputs */

8116
        {

8117
          struct _ssPortInputs *inputPortInfo =

8118
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

8119
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

8120
          _ssSetNumInputPorts(childS, 7);

8121
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

8122


8123
          /* port 0 */

8124
          {

8125
            real32_T const **sfcnUPtrs = (real32_T const **)

8126
              malloc(1 * sizeof(real32_T *));

8127
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8128
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8129
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

8130
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

8131
            _ssSetInputPortNumDimensions(childS, 0, 1);

8132
            ssSetInputPortWidth(childS, 0, 1);

8133
          }

8134


8135
          /* port 1 */

8136
          {

8137
            int8_T const **sfcnUPtrs = (int8_T const **)

8138
              malloc(1 * sizeof(int8_T *));

8139
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8140
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

8141
              ssGetLocalBlockIO(rts))->DataTypeConversion1_p;

8142
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

8143
            _ssSetInputPortNumDimensions(childS, 1, 1);

8144
            ssSetInputPortWidth(childS, 1, 1);

8145
          }

8146


8147
          /* port 2 */

8148
          {

8149
            real32_T const **sfcnUPtrs = (real32_T const **)

8150
              malloc(1 * sizeof(real32_T *));

8151
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8152
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

8153
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

8154
            _ssSetInputPortNumDimensions(childS, 2, 1);

8155
            ssSetInputPortWidth(childS, 2, 1);

8156
          }

8157


8158
          /* port 3 */

8159
          {

8160
            real32_T const **sfcnUPtrs = (real32_T const **)

8161
              malloc(1 * sizeof(real32_T *));

8162
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8163
            sfcnUPtrs[0] = (real32_T const *)

8164
              &AFCS_MODEL1_ConstP.Constant10_Value_a;

8165
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

8166
            _ssSetInputPortNumDimensions(childS, 3, 1);

8167
            ssSetInputPortWidth(childS, 3, 1);

8168
          }

8169


8170
          /* port 4 */

8171
          {

8172
            real32_T const **sfcnUPtrs = (real32_T const **)

8173
              malloc(1 * sizeof(real32_T *));

8174
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8175
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8176
              ssGetLocalBlockIO(rts))->Switch_aj;

8177
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

8178
            _ssSetInputPortNumDimensions(childS, 4, 1);

8179
            ssSetInputPortWidth(childS, 4, 1);

8180
          }

8181


8182
          /* port 5 */

8183
          {

8184
            real32_T const **sfcnUPtrs = (real32_T const **)

8185
              malloc(1 * sizeof(real32_T *));

8186
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8187
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8188
              ssGetLocalBlockIO(rts))->Switch_aj;

8189
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

8190
            _ssSetInputPortNumDimensions(childS, 5, 1);

8191
            ssSetInputPortWidth(childS, 5, 1);

8192
          }

8193


8194
          /* port 6 */

8195
          {

8196
            real32_T const **sfcnUPtrs = (real32_T const **)

8197
              malloc(1 * sizeof(real32_T *));

8198
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8199
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8200
              ssGetLocalBlockIO(rts))->GeneratedSFunction_k1;

8201
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

8202
            _ssSetInputPortNumDimensions(childS, 6, 1);

8203
            ssSetInputPortWidth(childS, 6, 1);

8204
          }

8205
        }

8206


8207
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

8208
          RegNumOutputPorts);

8209
        ssSetRegNumOutputPortsFcnArg(childS,childS);

8210


8211
        /* outputs */

8212
        {

8213
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

8214
            calloc(1, sizeof(struct _ssPortOutputs));

8215
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

8216
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

8217
          _ssSetNumOutputPorts(childS, 1);

8218


8219
          /* port 0 */

8220
          {

8221
            _ssSetOutputPortNumDimensions(childS, 0, 1);

8222
            ssSetOutputPortWidth(childS, 0, 1);

8223
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

8224
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_m));

8225
          }

8226
        }

8227


8228
        /* path info */

8229
        _ssSetModelName(childS, "LeadLagFilter_sf");

8230
        _ssSetPath(childS,

8231
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Lead lag/Generated S-Function2");

8232
        if (ssGetRTModel(rts) == (NULL)) {

8233
          _ssSetParentSS(childS, rts);

8234
          _ssSetRootSS(childS, ssGetRootSS(rts));

8235
        } else {

8236
          ssSetRTModel(childS,ssGetRTModel(rts));

8237
          _ssSetParentSS(childS, (NULL));

8238
          _ssSetRootSS(childS, childS);

8239
        }

8240


8241
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

8242


8243
        /* work vectors */

8244
        {

8245
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

8246
            (4 * sizeof(struct _ssDWorkRecord));

8247
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

8248
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

8249
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

8250
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

8251
          ssSetSFcnDWork(childS, dWorkRecord);

8252
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

8253
          _ssSetNumDWork(childS, 4);

8254


8255
          /* DWORK0 */

8256
          ssSetDWorkWidth(childS, 0, 1);

8257
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

8258
          ssSetDWorkComplexSignal(childS, 0, 0);

8259
          ssSetDWorkUsedAsDState(childS, 0, 1);

8260
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 170))[0]);

8261


8262
          /* DWORK1 */

8263
          ssSetDWorkWidth(childS, 1, 1);

8264
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

8265
          ssSetDWorkComplexSignal(childS, 1, 0);

8266
          ssSetDWorkUsedAsDState(childS, 1, 1);

8267
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 171))[0]);

8268


8269
          /* DWORK2 */

8270
          ssSetDWorkWidth(childS, 2, 1);

8271
          ssSetDWorkDataType(childS, 2,SS_INT8);

8272
          ssSetDWorkComplexSignal(childS, 2, 0);

8273
          ssSetDWorkUsedAsDState(childS, 2, 1);

8274
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 397))[0]);

8275


8276
          /* DWORK3 */

8277
          ssSetDWorkWidth(childS, 3, 1);

8278
          ssSetDWorkDataType(childS, 3,SS_INT8);

8279
          ssSetDWorkComplexSignal(childS, 3, 0);

8280
          ssSetDWorkUsedAsDState(childS, 3, 1);

8281
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 398))[0]);

8282
        }

8283


8284
        (childS)->regDataType.arg1 = ((void *)(childS));

8285
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

8286
          FcnSetErrorStatus);

8287
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

8288
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

8289
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

8290
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

8291


8292
        /* registration */

8293
#if defined(MATLAB_MEX_FILE)

8294


8295
        {

8296
          int_T i;

8297
          mxArray *plhs[1];

8298
          mxArray *prhs[4];

8299
          double *pr;

8300
          volatile int_T *intS = (int_T *)&childS;

8301
          int_T addrlen = sizeof(SimStruct *);

8302
          int_T m = addrlen/sizeof(int_T) + 1;

8303
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

8304
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

8305
          pr = mxGetPr(prhs[1]);

8306
          for (i = 0; i < m - 1; i++) {

8307
            pr[i] = (double)intS[i];

8308
          }

8309


8310
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

8311
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

8312
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

8313


8314
          /* Reset port dimensions info functions because the S-function

8315
           * and accelerator mex-files explicitly set their dimensions,

8316
           * i.e., they are not dynamically sized. For this case, the

8317
           * mex-file is responsible for the dimensions info memory

8318
           * and Simulink should not free it. This is achieved by

8319
           * setting the following two methods to NULL.

8320
           */

8321
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

8322
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

8323


8324
          /*

8325
           * Setup function pointers and call mdlInitializeSizes via

8326
           * simulink.c

8327
           */

8328
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

8329
          mxDestroyArray(plhs[0]);

8330
          mxDestroyArray(prhs[0]);

8331
          mxDestroyArray(prhs[1]);

8332
          mxDestroyArray(prhs[2]);

8333
          mxDestroyArray(prhs[3]);

8334
        }

8335


8336
#else

8337


8338
        {

8339
          LeadLagFilter_sf(childS);

8340
          sfcnInitializeSizes(childS);

8341
        }

8342


8343
#endif

8344


8345
        sfcnInitializeSampleTimes(childS);

8346


8347
        /* adjust sample time */

8348
        ssSetSampleTime(childS, 0, 0.0);

8349
        ssSetOffsetTime(childS, 0, 0.0);

8350
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

8351


8352
        /* set compiled values of dynamic vector attributes */

8353
        ssSetNumNonsampledZCs(childS, 0);

8354


8355
        /* Update connectivity flags for each port */

8356
        _ssSetInputPortConnected(childS, 0, 1);

8357
        _ssSetInputPortConnected(childS, 1, 1);

8358
        _ssSetInputPortConnected(childS, 2, 1);

8359
        _ssSetInputPortConnected(childS, 3, 1);

8360
        _ssSetInputPortConnected(childS, 4, 1);

8361
        _ssSetInputPortConnected(childS, 5, 1);

8362
        _ssSetInputPortConnected(childS, 6, 1);

8363
        _ssSetOutputPortConnected(childS, 0, 1);

8364
        _ssSetOutputPortBeingMerged(childS, 0, 0);

8365


8366
        /* Update the BufferDstPort flags for each input port */

8367
        _ssSetInputPortBufferDstPort(childS, 0, -1);

8368
        _ssSetInputPortBufferDstPort(childS, 1, -1);

8369
        _ssSetInputPortBufferDstPort(childS, 2, -1);

8370
        _ssSetInputPortBufferDstPort(childS, 3, -1);

8371
        _ssSetInputPortBufferDstPort(childS, 4, -1);

8372
        _ssSetInputPortBufferDstPort(childS, 5, -1);

8373
        _ssSetInputPortBufferDstPort(childS, 6, -1);

8374
      }

8375


8376
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S120>/Generated S-Function1 (SaturationLimiter_sf) */

8377
      {

8378
        SimStruct *childS = ssGetSFunction(rts, 31);

8379


8380
        /* timing info */

8381
        time_T *sfcnPeriod;

8382
        time_T *sfcnOffset;

8383
        int_T *sfcnTsMap;

8384
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

8385
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

8386
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

8387
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

8388
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

8389
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

8390
        (void) memset((void*)sfcnPeriod, 0,

8391
                      sizeof(time_T)*1);

8392
        (void) memset((void*)sfcnOffset, 0,

8393
                      sizeof(time_T)*1);

8394
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

8395
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

8396
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

8397


8398
        /* Set up the mdlInfo pointer */

8399
# ifdef USE_RTMODEL

8400


8401
        {

8402
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

8403
              struct _ssBlkInfo2));

8404
          ss_VALIDATE_MEMORY(rts,blkInfo2);

8405
          ssSetBlkInfo2Ptr(childS, blkInfo2);

8406
        }

8407


8408
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

8409


8410
# else

8411


8412
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

8413


8414
# endif                                /* USE_RTMODEL */

8415


8416
        /* Allocate memory of model methods 2 */

8417
        {

8418
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

8419
            malloc(sizeof(struct _ssSFcnModelMethods2));

8420
          ss_VALIDATE_MEMORY(rts,methods2);

8421
          ssSetModelMethods2(childS, methods2);

8422
        }

8423


8424
        /* Allocate memory of model methods 3 */

8425
        {

8426
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

8427
            malloc(sizeof(struct _ssSFcnModelMethods3));

8428
          ss_VALIDATE_MEMORY(rts,methods3);

8429
          ssSetModelMethods3(childS, methods3);

8430
        }

8431


8432
        /* Allocate memory for states auxilliary information */

8433
        {

8434
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

8435
            (sizeof(struct _ssStatesInfo2));

8436
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

8437
            malloc(sizeof(ssPeriodicStatesInfo));

8438
          ss_VALIDATE_MEMORY(rts,statesInfo2);

8439
          ssSetStatesInfo2(childS, statesInfo2);

8440
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

8441
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

8442
        }

8443


8444
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

8445
          RegNumInputPorts);

8446
        ssSetRegNumInputPortsFcnArg(childS,childS);

8447


8448
        /* inputs */

8449
        {

8450
          struct _ssPortInputs *inputPortInfo =

8451
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

8452
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

8453
          _ssSetNumInputPorts(childS, 3);

8454
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

8455


8456
          /* port 0 */

8457
          {

8458
            real32_T const **sfcnUPtrs = (real32_T const **)

8459
              malloc(1 * sizeof(real32_T *));

8460
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8461
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8462
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_m;

8463
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

8464
            _ssSetInputPortNumDimensions(childS, 0, 1);

8465
            ssSetInputPortWidth(childS, 0, 1);

8466
          }

8467


8468
          /* port 1 */

8469
          {

8470
            real32_T const **sfcnUPtrs = (real32_T const **)

8471
              malloc(1 * sizeof(real32_T *));

8472
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8473
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8474
              ssGetLocalBlockIO(rts))->Product1_m;

8475
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

8476
            _ssSetInputPortNumDimensions(childS, 1, 1);

8477
            ssSetInputPortWidth(childS, 1, 1);

8478
          }

8479


8480
          /* port 2 */

8481
          {

8482
            real32_T const **sfcnUPtrs = (real32_T const **)

8483
              malloc(1 * sizeof(real32_T *));

8484
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8485
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8486
              ssGetLocalBlockIO(rts))->Product_pp;

8487
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

8488
            _ssSetInputPortNumDimensions(childS, 2, 1);

8489
            ssSetInputPortWidth(childS, 2, 1);

8490
          }

8491
        }

8492


8493
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

8494
          RegNumOutputPorts);

8495
        ssSetRegNumOutputPortsFcnArg(childS,childS);

8496


8497
        /* outputs */

8498
        {

8499
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

8500
            calloc(1, sizeof(struct _ssPortOutputs));

8501
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

8502
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

8503
          _ssSetNumOutputPorts(childS, 1);

8504


8505
          /* port 0 */

8506
          {

8507
            _ssSetOutputPortNumDimensions(childS, 0, 1);

8508
            ssSetOutputPortWidth(childS, 0, 1);

8509
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

8510
              ssGetLocalBlockIO(rts))->Saturation8));

8511
          }

8512
        }

8513


8514
        /* path info */

8515
        _ssSetModelName(childS, "SaturationLimiter_sf");

8516
        _ssSetPath(childS,

8517
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Saturation Limiter1/Generated S-Function1");

8518
        if (ssGetRTModel(rts) == (NULL)) {

8519
          _ssSetParentSS(childS, rts);

8520
          _ssSetRootSS(childS, ssGetRootSS(rts));

8521
        } else {

8522
          ssSetRTModel(childS,ssGetRTModel(rts));

8523
          _ssSetParentSS(childS, (NULL));

8524
          _ssSetRootSS(childS, childS);

8525
        }

8526


8527
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

8528
        (childS)->regDataType.arg1 = ((void *)(childS));

8529
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

8530
          FcnSetErrorStatus);

8531
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

8532
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

8533
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

8534
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

8535


8536
        /* registration */

8537
#if defined(MATLAB_MEX_FILE)

8538


8539
        {

8540
          int_T i;

8541
          mxArray *plhs[1];

8542
          mxArray *prhs[4];

8543
          double *pr;

8544
          volatile int_T *intS = (int_T *)&childS;

8545
          int_T addrlen = sizeof(SimStruct *);

8546
          int_T m = addrlen/sizeof(int_T) + 1;

8547
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

8548
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

8549
          pr = mxGetPr(prhs[1]);

8550
          for (i = 0; i < m - 1; i++) {

8551
            pr[i] = (double)intS[i];

8552
          }

8553


8554
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

8555
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

8556
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

8557


8558
          /* Reset port dimensions info functions because the S-function

8559
           * and accelerator mex-files explicitly set their dimensions,

8560
           * i.e., they are not dynamically sized. For this case, the

8561
           * mex-file is responsible for the dimensions info memory

8562
           * and Simulink should not free it. This is achieved by

8563
           * setting the following two methods to NULL.

8564
           */

8565
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

8566
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

8567


8568
          /*

8569
           * Setup function pointers and call mdlInitializeSizes via

8570
           * simulink.c

8571
           */

8572
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

8573
          mxDestroyArray(plhs[0]);

8574
          mxDestroyArray(prhs[0]);

8575
          mxDestroyArray(prhs[1]);

8576
          mxDestroyArray(prhs[2]);

8577
          mxDestroyArray(prhs[3]);

8578
        }

8579


8580
#else

8581


8582
        {

8583
          SaturationLimiter_sf(childS);

8584
          sfcnInitializeSizes(childS);

8585
        }

8586


8587
#endif

8588


8589
        sfcnInitializeSampleTimes(childS);

8590


8591
        /* adjust sample time */

8592
        ssSetSampleTime(childS, 0, 0.0);

8593
        ssSetOffsetTime(childS, 0, 0.0);

8594
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

8595


8596
        /* set compiled values of dynamic vector attributes */

8597
        ssSetNumNonsampledZCs(childS, 0);

8598


8599
        /* Update connectivity flags for each port */

8600
        _ssSetInputPortConnected(childS, 0, 1);

8601
        _ssSetInputPortConnected(childS, 1, 1);

8602
        _ssSetInputPortConnected(childS, 2, 1);

8603
        _ssSetOutputPortConnected(childS, 0, 1);

8604
        _ssSetOutputPortBeingMerged(childS, 0, 0);

8605


8606
        /* Update the BufferDstPort flags for each input port */

8607
        _ssSetInputPortBufferDstPort(childS, 0, -1);

8608
        _ssSetInputPortBufferDstPort(childS, 1, -1);

8609
        _ssSetInputPortBufferDstPort(childS, 2, -1);

8610
      }

8611


8612
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S117>/Generated S-Function4 (LagFilter_sf) */

8613
      {

8614
        SimStruct *childS = ssGetSFunction(rts, 32);

8615


8616
        /* timing info */

8617
        time_T *sfcnPeriod;

8618
        time_T *sfcnOffset;

8619
        int_T *sfcnTsMap;

8620
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

8621
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

8622
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

8623
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

8624
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

8625
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

8626
        (void) memset((void*)sfcnPeriod, 0,

8627
                      sizeof(time_T)*1);

8628
        (void) memset((void*)sfcnOffset, 0,

8629
                      sizeof(time_T)*1);

8630
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

8631
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

8632
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

8633


8634
        /* Set up the mdlInfo pointer */

8635
# ifdef USE_RTMODEL

8636


8637
        {

8638
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

8639
              struct _ssBlkInfo2));

8640
          ss_VALIDATE_MEMORY(rts,blkInfo2);

8641
          ssSetBlkInfo2Ptr(childS, blkInfo2);

8642
        }

8643


8644
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

8645


8646
# else

8647


8648
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

8649


8650
# endif                                /* USE_RTMODEL */

8651


8652
        /* Allocate memory of model methods 2 */

8653
        {

8654
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

8655
            malloc(sizeof(struct _ssSFcnModelMethods2));

8656
          ss_VALIDATE_MEMORY(rts,methods2);

8657
          ssSetModelMethods2(childS, methods2);

8658
        }

8659


8660
        /* Allocate memory of model methods 3 */

8661
        {

8662
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

8663
            malloc(sizeof(struct _ssSFcnModelMethods3));

8664
          ss_VALIDATE_MEMORY(rts,methods3);

8665
          ssSetModelMethods3(childS, methods3);

8666
        }

8667


8668
        /* Allocate memory for states auxilliary information */

8669
        {

8670
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

8671
            (sizeof(struct _ssStatesInfo2));

8672
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

8673
            malloc(sizeof(ssPeriodicStatesInfo));

8674
          ss_VALIDATE_MEMORY(rts,statesInfo2);

8675
          ssSetStatesInfo2(childS, statesInfo2);

8676
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

8677
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

8678
        }

8679


8680
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

8681
          RegNumInputPorts);

8682
        ssSetRegNumInputPortsFcnArg(childS,childS);

8683


8684
        /* inputs */

8685
        {

8686
          struct _ssPortInputs *inputPortInfo =

8687
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

8688
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

8689
          _ssSetNumInputPorts(childS, 6);

8690
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

8691


8692
          /* port 0 */

8693
          {

8694
            real32_T const **sfcnUPtrs = (real32_T const **)

8695
              malloc(1 * sizeof(real32_T *));

8696
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8697
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8698
              ssGetLocalBlockIO(rts))->dtCAS;

8699
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

8700
            _ssSetInputPortNumDimensions(childS, 0, 1);

8701
            ssSetInputPortWidth(childS, 0, 1);

8702
          }

8703


8704
          /* port 1 */

8705
          {

8706
            int8_T const **sfcnUPtrs = (int8_T const **)

8707
              malloc(1 * sizeof(int8_T *));

8708
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8709
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

8710
              ssGetLocalBlockIO(rts))->DataTypeConversion1_p;

8711
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

8712
            _ssSetInputPortNumDimensions(childS, 1, 1);

8713
            ssSetInputPortWidth(childS, 1, 1);

8714
          }

8715


8716
          /* port 2 */

8717
          {

8718
            real32_T const **sfcnUPtrs = (real32_T const **)

8719
              malloc(1 * sizeof(real32_T *));

8720
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8721
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

8722
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

8723
            _ssSetInputPortNumDimensions(childS, 2, 1);

8724
            ssSetInputPortWidth(childS, 2, 1);

8725
          }

8726


8727
          /* port 3 */

8728
          {

8729
            real32_T const **sfcnUPtrs = (real32_T const **)

8730
              malloc(1 * sizeof(real32_T *));

8731
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8732
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8733
              ssGetLocalBlockIO(rts))->Sum1_e;

8734
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

8735
            _ssSetInputPortNumDimensions(childS, 3, 1);

8736
            ssSetInputPortWidth(childS, 3, 1);

8737
          }

8738


8739
          /* port 4 */

8740
          {

8741
            real32_T const **sfcnUPtrs = (real32_T const **)

8742
              malloc(1 * sizeof(real32_T *));

8743
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8744
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8745
              ssGetLocalBlockIO(rts))->Sum1_e;

8746
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

8747
            _ssSetInputPortNumDimensions(childS, 4, 1);

8748
            ssSetInputPortWidth(childS, 4, 1);

8749
          }

8750


8751
          /* port 5 */

8752
          {

8753
            real32_T const **sfcnUPtrs = (real32_T const **)

8754
              malloc(1 * sizeof(real32_T *));

8755
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

8756
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

8757
              ssGetLocalBlockIO(rts))->Sum2_eb;

8758
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

8759
            _ssSetInputPortNumDimensions(childS, 5, 1);

8760
            ssSetInputPortWidth(childS, 5, 1);

8761
          }

8762
        }

8763


8764
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

8765
          RegNumOutputPorts);

8766
        ssSetRegNumOutputPortsFcnArg(childS,childS);

8767


8768
        /* outputs */

8769
        {

8770
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

8771
            calloc(1, sizeof(struct _ssPortOutputs));

8772
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

8773
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

8774
          _ssSetNumOutputPorts(childS, 1);

8775


8776
          /* port 0 */

8777
          {

8778
            _ssSetOutputPortNumDimensions(childS, 0, 1);

8779
            ssSetOutputPortWidth(childS, 0, 1);

8780
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

8781
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_d));

8782
          }

8783
        }

8784


8785
        /* path info */

8786
        _ssSetModelName(childS, "LagFilter_sf");

8787
        _ssSetPath(childS,

8788
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/ lag filter1/Generated S-Function4");

8789
        if (ssGetRTModel(rts) == (NULL)) {

8790
          _ssSetParentSS(childS, rts);

8791
          _ssSetRootSS(childS, ssGetRootSS(rts));

8792
        } else {

8793
          ssSetRTModel(childS,ssGetRTModel(rts));

8794
          _ssSetParentSS(childS, (NULL));

8795
          _ssSetRootSS(childS, childS);

8796
        }

8797


8798
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

8799


8800
        /* work vectors */

8801
        {

8802
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

8803
            (4 * sizeof(struct _ssDWorkRecord));

8804
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

8805
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

8806
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

8807
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

8808
          ssSetSFcnDWork(childS, dWorkRecord);

8809
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

8810
          _ssSetNumDWork(childS, 4);

8811


8812
          /* DWORK0 */

8813
          ssSetDWorkWidth(childS, 0, 1);

8814
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

8815
          ssSetDWorkComplexSignal(childS, 0, 0);

8816
          ssSetDWorkUsedAsDState(childS, 0, 1);

8817
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 172))[0]);

8818


8819
          /* DWORK1 */

8820
          ssSetDWorkWidth(childS, 1, 1);

8821
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

8822
          ssSetDWorkComplexSignal(childS, 1, 0);

8823
          ssSetDWorkUsedAsDState(childS, 1, 1);

8824
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 173))[0]);

8825


8826
          /* DWORK2 */

8827
          ssSetDWorkWidth(childS, 2, 1);

8828
          ssSetDWorkDataType(childS, 2,SS_INT8);

8829
          ssSetDWorkComplexSignal(childS, 2, 0);

8830
          ssSetDWorkUsedAsDState(childS, 2, 1);

8831
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 399))[0]);

8832


8833
          /* DWORK3 */

8834
          ssSetDWorkWidth(childS, 3, 1);

8835
          ssSetDWorkDataType(childS, 3,SS_INT8);

8836
          ssSetDWorkComplexSignal(childS, 3, 0);

8837
          ssSetDWorkUsedAsDState(childS, 3, 1);

8838
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 400))[0]);

8839
        }

8840


8841
        (childS)->regDataType.arg1 = ((void *)(childS));

8842
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

8843
          FcnSetErrorStatus);

8844
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

8845
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

8846
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

8847
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

8848


8849
        /* registration */

8850
#if defined(MATLAB_MEX_FILE)

8851


8852
        {

8853
          int_T i;

8854
          mxArray *plhs[1];

8855
          mxArray *prhs[4];

8856
          double *pr;

8857
          volatile int_T *intS = (int_T *)&childS;

8858
          int_T addrlen = sizeof(SimStruct *);

8859
          int_T m = addrlen/sizeof(int_T) + 1;

8860
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

8861
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

8862
          pr = mxGetPr(prhs[1]);

8863
          for (i = 0; i < m - 1; i++) {

8864
            pr[i] = (double)intS[i];

8865
          }

8866


8867
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

8868
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

8869
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

8870


8871
          /* Reset port dimensions info functions because the S-function

8872
           * and accelerator mex-files explicitly set their dimensions,

8873
           * i.e., they are not dynamically sized. For this case, the

8874
           * mex-file is responsible for the dimensions info memory

8875
           * and Simulink should not free it. This is achieved by

8876
           * setting the following two methods to NULL.

8877
           */

8878
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

8879
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

8880


8881
          /*

8882
           * Setup function pointers and call mdlInitializeSizes via

8883
           * simulink.c

8884
           */

8885
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

8886
          mxDestroyArray(plhs[0]);

8887
          mxDestroyArray(prhs[0]);

8888
          mxDestroyArray(prhs[1]);

8889
          mxDestroyArray(prhs[2]);

8890
          mxDestroyArray(prhs[3]);

8891
        }

8892


8893
#else

8894


8895
        {

8896
          LagFilter_sf(childS);

8897
          sfcnInitializeSizes(childS);

8898
        }

8899


8900
#endif

8901


8902
        sfcnInitializeSampleTimes(childS);

8903


8904
        /* adjust sample time */

8905
        ssSetSampleTime(childS, 0, 0.0);

8906
        ssSetOffsetTime(childS, 0, 0.0);

8907
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

8908


8909
        /* set compiled values of dynamic vector attributes */

8910
        ssSetNumNonsampledZCs(childS, 0);

8911


8912
        /* Update connectivity flags for each port */

8913
        _ssSetInputPortConnected(childS, 0, 1);

8914
        _ssSetInputPortConnected(childS, 1, 1);

8915
        _ssSetInputPortConnected(childS, 2, 1);

8916
        _ssSetInputPortConnected(childS, 3, 1);

8917
        _ssSetInputPortConnected(childS, 4, 1);

8918
        _ssSetInputPortConnected(childS, 5, 1);

8919
        _ssSetOutputPortConnected(childS, 0, 1);

8920
        _ssSetOutputPortBeingMerged(childS, 0, 0);

8921


8922
        /* Update the BufferDstPort flags for each input port */

8923
        _ssSetInputPortBufferDstPort(childS, 0, -1);

8924
        _ssSetInputPortBufferDstPort(childS, 1, -1);

8925
        _ssSetInputPortBufferDstPort(childS, 2, -1);

8926
        _ssSetInputPortBufferDstPort(childS, 3, -1);

8927
        _ssSetInputPortBufferDstPort(childS, 4, -1);

8928
        _ssSetInputPortBufferDstPort(childS, 5, -1);

8929
      }

8930


8931
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S122>/Generated S-Function (Gain_sf) */

8932
      {

8933
        SimStruct *childS = ssGetSFunction(rts, 33);

8934


8935
        /* timing info */

8936
        time_T *sfcnPeriod;

8937
        time_T *sfcnOffset;

8938
        int_T *sfcnTsMap;

8939
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

8940
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

8941
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

8942
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

8943
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

8944
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

8945
        (void) memset((void*)sfcnPeriod, 0,

8946
                      sizeof(time_T)*1);

8947
        (void) memset((void*)sfcnOffset, 0,

8948
                      sizeof(time_T)*1);

8949
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

8950
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

8951
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

8952


8953
        /* Set up the mdlInfo pointer */

8954
# ifdef USE_RTMODEL

8955


8956
        {

8957
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

8958
              struct _ssBlkInfo2));

8959
          ss_VALIDATE_MEMORY(rts,blkInfo2);

8960
          ssSetBlkInfo2Ptr(childS, blkInfo2);

8961
        }

8962


8963
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

8964


8965
# else

8966


8967
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

8968


8969
# endif                                /* USE_RTMODEL */

8970


8971
        /* Allocate memory of model methods 2 */

8972
        {

8973
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

8974
            malloc(sizeof(struct _ssSFcnModelMethods2));

8975
          ss_VALIDATE_MEMORY(rts,methods2);

8976
          ssSetModelMethods2(childS, methods2);

8977
        }

8978


8979
        /* Allocate memory of model methods 3 */

8980
        {

8981
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

8982
            malloc(sizeof(struct _ssSFcnModelMethods3));

8983
          ss_VALIDATE_MEMORY(rts,methods3);

8984
          ssSetModelMethods3(childS, methods3);

8985
        }

8986


8987
        /* Allocate memory for states auxilliary information */

8988
        {

8989
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

8990
            (sizeof(struct _ssStatesInfo2));

8991
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

8992
            malloc(sizeof(ssPeriodicStatesInfo));

8993
          ss_VALIDATE_MEMORY(rts,statesInfo2);

8994
          ssSetStatesInfo2(childS, statesInfo2);

8995
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

8996
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

8997
        }

8998


8999
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

9000
          RegNumInputPorts);

9001
        ssSetRegNumInputPortsFcnArg(childS,childS);

9002


9003
        /* inputs */

9004
        {

9005
          struct _ssPortInputs *inputPortInfo =

9006
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

9007
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

9008
          _ssSetNumInputPorts(childS, 2);

9009
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

9010


9011
          /* port 0 */

9012
          {

9013
            real32_T const **sfcnUPtrs = (real32_T const **)

9014
              malloc(1 * sizeof(real32_T *));

9015
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9016
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

9017
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_d;

9018
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

9019
            _ssSetInputPortNumDimensions(childS, 0, 1);

9020
            ssSetInputPortWidth(childS, 0, 1);

9021
          }

9022


9023
          /* port 1 */

9024
          {

9025
            real32_T const **sfcnUPtrs = (real32_T const **)

9026
              malloc(1 * sizeof(real32_T *));

9027
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9028
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

9029
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

9030
            _ssSetInputPortNumDimensions(childS, 1, 1);

9031
            ssSetInputPortWidth(childS, 1, 1);

9032
          }

9033
        }

9034


9035
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

9036
          RegNumOutputPorts);

9037
        ssSetRegNumOutputPortsFcnArg(childS,childS);

9038


9039
        /* outputs */

9040
        {

9041
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

9042
            calloc(1, sizeof(struct _ssPortOutputs));

9043
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

9044
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

9045
          _ssSetNumOutputPorts(childS, 1);

9046


9047
          /* port 0 */

9048
          {

9049
            _ssSetOutputPortNumDimensions(childS, 0, 1);

9050
            ssSetOutputPortWidth(childS, 0, 1);

9051
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

9052
              ssGetLocalBlockIO(rts))->Switch6_d));

9053
          }

9054
        }

9055


9056
        /* path info */

9057
        _ssSetModelName(childS, "Gain_sf");

9058
        _ssSetPath(childS,

9059
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/gain1/Generated S-Function");

9060
        if (ssGetRTModel(rts) == (NULL)) {

9061
          _ssSetParentSS(childS, rts);

9062
          _ssSetRootSS(childS, ssGetRootSS(rts));

9063
        } else {

9064
          ssSetRTModel(childS,ssGetRTModel(rts));

9065
          _ssSetParentSS(childS, (NULL));

9066
          _ssSetRootSS(childS, childS);

9067
        }

9068


9069
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

9070
        (childS)->regDataType.arg1 = ((void *)(childS));

9071
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

9072
          FcnSetErrorStatus);

9073
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

9074
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

9075
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

9076
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

9077


9078
        /* registration */

9079
#if defined(MATLAB_MEX_FILE)

9080


9081
        {

9082
          int_T i;

9083
          mxArray *plhs[1];

9084
          mxArray *prhs[4];

9085
          double *pr;

9086
          volatile int_T *intS = (int_T *)&childS;

9087
          int_T addrlen = sizeof(SimStruct *);

9088
          int_T m = addrlen/sizeof(int_T) + 1;

9089
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

9090
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

9091
          pr = mxGetPr(prhs[1]);

9092
          for (i = 0; i < m - 1; i++) {

9093
            pr[i] = (double)intS[i];

9094
          }

9095


9096
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

9097
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

9098
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

9099


9100
          /* Reset port dimensions info functions because the S-function

9101
           * and accelerator mex-files explicitly set their dimensions,

9102
           * i.e., they are not dynamically sized. For this case, the

9103
           * mex-file is responsible for the dimensions info memory

9104
           * and Simulink should not free it. This is achieved by

9105
           * setting the following two methods to NULL.

9106
           */

9107
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

9108
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

9109


9110
          /*

9111
           * Setup function pointers and call mdlInitializeSizes via

9112
           * simulink.c

9113
           */

9114
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

9115
          mxDestroyArray(plhs[0]);

9116
          mxDestroyArray(prhs[0]);

9117
          mxDestroyArray(prhs[1]);

9118
          mxDestroyArray(prhs[2]);

9119
          mxDestroyArray(prhs[3]);

9120
        }

9121


9122
#else

9123


9124
        {

9125
          Gain_sf(childS);

9126
          sfcnInitializeSizes(childS);

9127
        }

9128


9129
#endif

9130


9131
        sfcnInitializeSampleTimes(childS);

9132


9133
        /* adjust sample time */

9134
        ssSetSampleTime(childS, 0, 0.0);

9135
        ssSetOffsetTime(childS, 0, 0.0);

9136
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

9137


9138
        /* set compiled values of dynamic vector attributes */

9139
        ssSetNumNonsampledZCs(childS, 0);

9140


9141
        /* Update connectivity flags for each port */

9142
        _ssSetInputPortConnected(childS, 0, 1);

9143
        _ssSetInputPortConnected(childS, 1, 1);

9144
        _ssSetOutputPortConnected(childS, 0, 1);

9145
        _ssSetOutputPortBeingMerged(childS, 0, 0);

9146


9147
        /* Update the BufferDstPort flags for each input port */

9148
        _ssSetInputPortBufferDstPort(childS, 0, -1);

9149
        _ssSetInputPortBufferDstPort(childS, 1, -1);

9150
      }

9151


9152
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S116>/Generated S-Function4 (LagFilter_sf) */

9153
      {

9154
        SimStruct *childS = ssGetSFunction(rts, 34);

9155


9156
        /* timing info */

9157
        time_T *sfcnPeriod;

9158
        time_T *sfcnOffset;

9159
        int_T *sfcnTsMap;

9160
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

9161
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

9162
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

9163
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

9164
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

9165
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

9166
        (void) memset((void*)sfcnPeriod, 0,

9167
                      sizeof(time_T)*1);

9168
        (void) memset((void*)sfcnOffset, 0,

9169
                      sizeof(time_T)*1);

9170
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

9171
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

9172
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

9173


9174
        /* Set up the mdlInfo pointer */

9175
# ifdef USE_RTMODEL

9176


9177
        {

9178
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

9179
              struct _ssBlkInfo2));

9180
          ss_VALIDATE_MEMORY(rts,blkInfo2);

9181
          ssSetBlkInfo2Ptr(childS, blkInfo2);

9182
        }

9183


9184
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

9185


9186
# else

9187


9188
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

9189


9190
# endif                                /* USE_RTMODEL */

9191


9192
        /* Allocate memory of model methods 2 */

9193
        {

9194
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

9195
            malloc(sizeof(struct _ssSFcnModelMethods2));

9196
          ss_VALIDATE_MEMORY(rts,methods2);

9197
          ssSetModelMethods2(childS, methods2);

9198
        }

9199


9200
        /* Allocate memory of model methods 3 */

9201
        {

9202
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

9203
            malloc(sizeof(struct _ssSFcnModelMethods3));

9204
          ss_VALIDATE_MEMORY(rts,methods3);

9205
          ssSetModelMethods3(childS, methods3);

9206
        }

9207


9208
        /* Allocate memory for states auxilliary information */

9209
        {

9210
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

9211
            (sizeof(struct _ssStatesInfo2));

9212
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

9213
            malloc(sizeof(ssPeriodicStatesInfo));

9214
          ss_VALIDATE_MEMORY(rts,statesInfo2);

9215
          ssSetStatesInfo2(childS, statesInfo2);

9216
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

9217
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

9218
        }

9219


9220
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

9221
          RegNumInputPorts);

9222
        ssSetRegNumInputPortsFcnArg(childS,childS);

9223


9224
        /* inputs */

9225
        {

9226
          struct _ssPortInputs *inputPortInfo =

9227
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

9228
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

9229
          _ssSetNumInputPorts(childS, 6);

9230
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

9231


9232
          /* port 0 */

9233
          {

9234
            real32_T const **sfcnUPtrs = (real32_T const **)

9235
              malloc(1 * sizeof(real32_T *));

9236
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9237
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

9238
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

9239
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

9240
            _ssSetInputPortNumDimensions(childS, 0, 1);

9241
            ssSetInputPortWidth(childS, 0, 1);

9242
          }

9243


9244
          /* port 1 */

9245
          {

9246
            int8_T const **sfcnUPtrs = (int8_T const **)

9247
              malloc(1 * sizeof(int8_T *));

9248
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9249
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

9250
              ssGetLocalBlockIO(rts))->DataTypeConversion1_p;

9251
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

9252
            _ssSetInputPortNumDimensions(childS, 1, 1);

9253
            ssSetInputPortWidth(childS, 1, 1);

9254
          }

9255


9256
          /* port 2 */

9257
          {

9258
            real32_T const **sfcnUPtrs = (real32_T const **)

9259
              malloc(1 * sizeof(real32_T *));

9260
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9261
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

9262
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

9263
            _ssSetInputPortNumDimensions(childS, 2, 1);

9264
            ssSetInputPortWidth(childS, 2, 1);

9265
          }

9266


9267
          /* port 3 */

9268
          {

9269
            real32_T const **sfcnUPtrs = (real32_T const **)

9270
              malloc(1 * sizeof(real32_T *));

9271
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9272
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

9273
              ssGetLocalBlockIO(rts))->Switch_aj;

9274
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

9275
            _ssSetInputPortNumDimensions(childS, 3, 1);

9276
            ssSetInputPortWidth(childS, 3, 1);

9277
          }

9278


9279
          /* port 4 */

9280
          {

9281
            real32_T const **sfcnUPtrs = (real32_T const **)

9282
              malloc(1 * sizeof(real32_T *));

9283
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9284
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

9285
              ssGetLocalBlockIO(rts))->Switch_aj;

9286
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

9287
            _ssSetInputPortNumDimensions(childS, 4, 1);

9288
            ssSetInputPortWidth(childS, 4, 1);

9289
          }

9290


9291
          /* port 5 */

9292
          {

9293
            real32_T const **sfcnUPtrs = (real32_T const **)

9294
              malloc(1 * sizeof(real32_T *));

9295
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9296
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

9297
              ssGetLocalBlockIO(rts))->Sum3_l;

9298
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

9299
            _ssSetInputPortNumDimensions(childS, 5, 1);

9300
            ssSetInputPortWidth(childS, 5, 1);

9301
          }

9302
        }

9303


9304
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

9305
          RegNumOutputPorts);

9306
        ssSetRegNumOutputPortsFcnArg(childS,childS);

9307


9308
        /* outputs */

9309
        {

9310
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

9311
            calloc(1, sizeof(struct _ssPortOutputs));

9312
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

9313
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

9314
          _ssSetNumOutputPorts(childS, 1);

9315


9316
          /* port 0 */

9317
          {

9318
            _ssSetOutputPortNumDimensions(childS, 0, 1);

9319
            ssSetOutputPortWidth(childS, 0, 1);

9320
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

9321
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_f));

9322
          }

9323
        }

9324


9325
        /* path info */

9326
        _ssSetModelName(childS, "LagFilter_sf");

9327
        _ssSetPath(childS,

9328
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/ lag filter/Generated S-Function4");

9329
        if (ssGetRTModel(rts) == (NULL)) {

9330
          _ssSetParentSS(childS, rts);

9331
          _ssSetRootSS(childS, ssGetRootSS(rts));

9332
        } else {

9333
          ssSetRTModel(childS,ssGetRTModel(rts));

9334
          _ssSetParentSS(childS, (NULL));

9335
          _ssSetRootSS(childS, childS);

9336
        }

9337


9338
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

9339


9340
        /* work vectors */

9341
        {

9342
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

9343
            (4 * sizeof(struct _ssDWorkRecord));

9344
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

9345
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

9346
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

9347
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

9348
          ssSetSFcnDWork(childS, dWorkRecord);

9349
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

9350
          _ssSetNumDWork(childS, 4);

9351


9352
          /* DWORK0 */

9353
          ssSetDWorkWidth(childS, 0, 1);

9354
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

9355
          ssSetDWorkComplexSignal(childS, 0, 0);

9356
          ssSetDWorkUsedAsDState(childS, 0, 1);

9357
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 174))[0]);

9358


9359
          /* DWORK1 */

9360
          ssSetDWorkWidth(childS, 1, 1);

9361
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

9362
          ssSetDWorkComplexSignal(childS, 1, 0);

9363
          ssSetDWorkUsedAsDState(childS, 1, 1);

9364
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 175))[0]);

9365


9366
          /* DWORK2 */

9367
          ssSetDWorkWidth(childS, 2, 1);

9368
          ssSetDWorkDataType(childS, 2,SS_INT8);

9369
          ssSetDWorkComplexSignal(childS, 2, 0);

9370
          ssSetDWorkUsedAsDState(childS, 2, 1);

9371
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 401))[0]);

9372


9373
          /* DWORK3 */

9374
          ssSetDWorkWidth(childS, 3, 1);

9375
          ssSetDWorkDataType(childS, 3,SS_INT8);

9376
          ssSetDWorkComplexSignal(childS, 3, 0);

9377
          ssSetDWorkUsedAsDState(childS, 3, 1);

9378
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 402))[0]);

9379
        }

9380


9381
        (childS)->regDataType.arg1 = ((void *)(childS));

9382
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

9383
          FcnSetErrorStatus);

9384
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

9385
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

9386
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

9387
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

9388


9389
        /* registration */

9390
#if defined(MATLAB_MEX_FILE)

9391


9392
        {

9393
          int_T i;

9394
          mxArray *plhs[1];

9395
          mxArray *prhs[4];

9396
          double *pr;

9397
          volatile int_T *intS = (int_T *)&childS;

9398
          int_T addrlen = sizeof(SimStruct *);

9399
          int_T m = addrlen/sizeof(int_T) + 1;

9400
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

9401
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

9402
          pr = mxGetPr(prhs[1]);

9403
          for (i = 0; i < m - 1; i++) {

9404
            pr[i] = (double)intS[i];

9405
          }

9406


9407
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

9408
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

9409
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

9410


9411
          /* Reset port dimensions info functions because the S-function

9412
           * and accelerator mex-files explicitly set their dimensions,

9413
           * i.e., they are not dynamically sized. For this case, the

9414
           * mex-file is responsible for the dimensions info memory

9415
           * and Simulink should not free it. This is achieved by

9416
           * setting the following two methods to NULL.

9417
           */

9418
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

9419
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

9420


9421
          /*

9422
           * Setup function pointers and call mdlInitializeSizes via

9423
           * simulink.c

9424
           */

9425
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

9426
          mxDestroyArray(plhs[0]);

9427
          mxDestroyArray(prhs[0]);

9428
          mxDestroyArray(prhs[1]);

9429
          mxDestroyArray(prhs[2]);

9430
          mxDestroyArray(prhs[3]);

9431
        }

9432


9433
#else

9434


9435
        {

9436
          LagFilter_sf(childS);

9437
          sfcnInitializeSizes(childS);

9438
        }

9439


9440
#endif

9441


9442
        sfcnInitializeSampleTimes(childS);

9443


9444
        /* adjust sample time */

9445
        ssSetSampleTime(childS, 0, 0.0);

9446
        ssSetOffsetTime(childS, 0, 0.0);

9447
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

9448


9449
        /* set compiled values of dynamic vector attributes */

9450
        ssSetNumNonsampledZCs(childS, 0);

9451


9452
        /* Update connectivity flags for each port */

9453
        _ssSetInputPortConnected(childS, 0, 1);

9454
        _ssSetInputPortConnected(childS, 1, 1);

9455
        _ssSetInputPortConnected(childS, 2, 1);

9456
        _ssSetInputPortConnected(childS, 3, 1);

9457
        _ssSetInputPortConnected(childS, 4, 1);

9458
        _ssSetInputPortConnected(childS, 5, 1);

9459
        _ssSetOutputPortConnected(childS, 0, 1);

9460
        _ssSetOutputPortBeingMerged(childS, 0, 0);

9461


9462
        /* Update the BufferDstPort flags for each input port */

9463
        _ssSetInputPortBufferDstPort(childS, 0, -1);

9464
        _ssSetInputPortBufferDstPort(childS, 1, -1);

9465
        _ssSetInputPortBufferDstPort(childS, 2, -1);

9466
        _ssSetInputPortBufferDstPort(childS, 3, -1);

9467
        _ssSetInputPortBufferDstPort(childS, 4, -1);

9468
        _ssSetInputPortBufferDstPort(childS, 5, -1);

9469
      }

9470


9471
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S102>/Generated S-Function1 (SaturationLimiter_sf) */

9472
      {

9473
        SimStruct *childS = ssGetSFunction(rts, 35);

9474


9475
        /* timing info */

9476
        time_T *sfcnPeriod;

9477
        time_T *sfcnOffset;

9478
        int_T *sfcnTsMap;

9479
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

9480
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

9481
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

9482
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

9483
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

9484
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

9485
        (void) memset((void*)sfcnPeriod, 0,

9486
                      sizeof(time_T)*1);

9487
        (void) memset((void*)sfcnOffset, 0,

9488
                      sizeof(time_T)*1);

9489
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

9490
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

9491
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

9492


9493
        /* Set up the mdlInfo pointer */

9494
# ifdef USE_RTMODEL

9495


9496
        {

9497
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

9498
              struct _ssBlkInfo2));

9499
          ss_VALIDATE_MEMORY(rts,blkInfo2);

9500
          ssSetBlkInfo2Ptr(childS, blkInfo2);

9501
        }

9502


9503
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

9504


9505
# else

9506


9507
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

9508


9509
# endif                                /* USE_RTMODEL */

9510


9511
        /* Allocate memory of model methods 2 */

9512
        {

9513
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

9514
            malloc(sizeof(struct _ssSFcnModelMethods2));

9515
          ss_VALIDATE_MEMORY(rts,methods2);

9516
          ssSetModelMethods2(childS, methods2);

9517
        }

9518


9519
        /* Allocate memory of model methods 3 */

9520
        {

9521
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

9522
            malloc(sizeof(struct _ssSFcnModelMethods3));

9523
          ss_VALIDATE_MEMORY(rts,methods3);

9524
          ssSetModelMethods3(childS, methods3);

9525
        }

9526


9527
        /* Allocate memory for states auxilliary information */

9528
        {

9529
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

9530
            (sizeof(struct _ssStatesInfo2));

9531
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

9532
            malloc(sizeof(ssPeriodicStatesInfo));

9533
          ss_VALIDATE_MEMORY(rts,statesInfo2);

9534
          ssSetStatesInfo2(childS, statesInfo2);

9535
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

9536
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

9537
        }

9538


9539
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

9540
          RegNumInputPorts);

9541
        ssSetRegNumInputPortsFcnArg(childS,childS);

9542


9543
        /* inputs */

9544
        {

9545
          struct _ssPortInputs *inputPortInfo =

9546
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

9547
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

9548
          _ssSetNumInputPorts(childS, 3);

9549
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

9550


9551
          /* port 0 */

9552
          {

9553
            real32_T const **sfcnUPtrs = (real32_T const **)

9554
              malloc(1 * sizeof(real32_T *));

9555
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9556
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

9557
              ssGetLocalBlockIO(rts))->Sum1_l;

9558
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

9559
            _ssSetInputPortNumDimensions(childS, 0, 1);

9560
            ssSetInputPortWidth(childS, 0, 1);

9561
          }

9562


9563
          /* port 1 */

9564
          {

9565
            real32_T const **sfcnUPtrs = (real32_T const **)

9566
              malloc(1 * sizeof(real32_T *));

9567
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9568
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

9569
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

9570
            _ssSetInputPortNumDimensions(childS, 1, 1);

9571
            ssSetInputPortWidth(childS, 1, 1);

9572
          }

9573


9574
          /* port 2 */

9575
          {

9576
            real32_T const **sfcnUPtrs = (real32_T const **)

9577
              malloc(1 * sizeof(real32_T *));

9578
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9579
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

9580
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

9581
            _ssSetInputPortNumDimensions(childS, 2, 1);

9582
            ssSetInputPortWidth(childS, 2, 1);

9583
          }

9584
        }

9585


9586
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

9587
          RegNumOutputPorts);

9588
        ssSetRegNumOutputPortsFcnArg(childS,childS);

9589


9590
        /* outputs */

9591
        {

9592
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

9593
            calloc(1, sizeof(struct _ssPortOutputs));

9594
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

9595
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

9596
          _ssSetNumOutputPorts(childS, 1);

9597


9598
          /* port 0 */

9599
          {

9600
            _ssSetOutputPortNumDimensions(childS, 0, 1);

9601
            ssSetOutputPortWidth(childS, 0, 1);

9602
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

9603
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_n));

9604
          }

9605
        }

9606


9607
        /* path info */

9608
        _ssSetModelName(childS, "SaturationLimiter_sf");

9609
        _ssSetPath(childS,

9610
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Saturation Limiter1/Generated S-Function1");

9611
        if (ssGetRTModel(rts) == (NULL)) {

9612
          _ssSetParentSS(childS, rts);

9613
          _ssSetRootSS(childS, ssGetRootSS(rts));

9614
        } else {

9615
          ssSetRTModel(childS,ssGetRTModel(rts));

9616
          _ssSetParentSS(childS, (NULL));

9617
          _ssSetRootSS(childS, childS);

9618
        }

9619


9620
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

9621
        (childS)->regDataType.arg1 = ((void *)(childS));

9622
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

9623
          FcnSetErrorStatus);

9624
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

9625
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

9626
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

9627
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

9628


9629
        /* registration */

9630
#if defined(MATLAB_MEX_FILE)

9631


9632
        {

9633
          int_T i;

9634
          mxArray *plhs[1];

9635
          mxArray *prhs[4];

9636
          double *pr;

9637
          volatile int_T *intS = (int_T *)&childS;

9638
          int_T addrlen = sizeof(SimStruct *);

9639
          int_T m = addrlen/sizeof(int_T) + 1;

9640
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

9641
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

9642
          pr = mxGetPr(prhs[1]);

9643
          for (i = 0; i < m - 1; i++) {

9644
            pr[i] = (double)intS[i];

9645
          }

9646


9647
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

9648
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

9649
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

9650


9651
          /* Reset port dimensions info functions because the S-function

9652
           * and accelerator mex-files explicitly set their dimensions,

9653
           * i.e., they are not dynamically sized. For this case, the

9654
           * mex-file is responsible for the dimensions info memory

9655
           * and Simulink should not free it. This is achieved by

9656
           * setting the following two methods to NULL.

9657
           */

9658
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

9659
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

9660


9661
          /*

9662
           * Setup function pointers and call mdlInitializeSizes via

9663
           * simulink.c

9664
           */

9665
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

9666
          mxDestroyArray(plhs[0]);

9667
          mxDestroyArray(prhs[0]);

9668
          mxDestroyArray(prhs[1]);

9669
          mxDestroyArray(prhs[2]);

9670
          mxDestroyArray(prhs[3]);

9671
        }

9672


9673
#else

9674


9675
        {

9676
          SaturationLimiter_sf(childS);

9677
          sfcnInitializeSizes(childS);

9678
        }

9679


9680
#endif

9681


9682
        sfcnInitializeSampleTimes(childS);

9683


9684
        /* adjust sample time */

9685
        ssSetSampleTime(childS, 0, 0.0);

9686
        ssSetOffsetTime(childS, 0, 0.0);

9687
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

9688


9689
        /* set compiled values of dynamic vector attributes */

9690
        ssSetNumNonsampledZCs(childS, 0);

9691


9692
        /* Update connectivity flags for each port */

9693
        _ssSetInputPortConnected(childS, 0, 1);

9694
        _ssSetInputPortConnected(childS, 1, 1);

9695
        _ssSetInputPortConnected(childS, 2, 1);

9696
        _ssSetOutputPortConnected(childS, 0, 1);

9697
        _ssSetOutputPortBeingMerged(childS, 0, 0);

9698


9699
        /* Update the BufferDstPort flags for each input port */

9700
        _ssSetInputPortBufferDstPort(childS, 0, -1);

9701
        _ssSetInputPortBufferDstPort(childS, 1, -1);

9702
        _ssSetInputPortBufferDstPort(childS, 2, -1);

9703
      }

9704


9705
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S104>/Generated S-Function (Gain_sf) */

9706
      {

9707
        SimStruct *childS = ssGetSFunction(rts, 36);

9708


9709
        /* timing info */

9710
        time_T *sfcnPeriod;

9711
        time_T *sfcnOffset;

9712
        int_T *sfcnTsMap;

9713
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

9714
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

9715
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

9716
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

9717
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

9718
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

9719
        (void) memset((void*)sfcnPeriod, 0,

9720
                      sizeof(time_T)*1);

9721
        (void) memset((void*)sfcnOffset, 0,

9722
                      sizeof(time_T)*1);

9723
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

9724
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

9725
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

9726


9727
        /* Set up the mdlInfo pointer */

9728
# ifdef USE_RTMODEL

9729


9730
        {

9731
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

9732
              struct _ssBlkInfo2));

9733
          ss_VALIDATE_MEMORY(rts,blkInfo2);

9734
          ssSetBlkInfo2Ptr(childS, blkInfo2);

9735
        }

9736


9737
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

9738


9739
# else

9740


9741
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

9742


9743
# endif                                /* USE_RTMODEL */

9744


9745
        /* Allocate memory of model methods 2 */

9746
        {

9747
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

9748
            malloc(sizeof(struct _ssSFcnModelMethods2));

9749
          ss_VALIDATE_MEMORY(rts,methods2);

9750
          ssSetModelMethods2(childS, methods2);

9751
        }

9752


9753
        /* Allocate memory of model methods 3 */

9754
        {

9755
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

9756
            malloc(sizeof(struct _ssSFcnModelMethods3));

9757
          ss_VALIDATE_MEMORY(rts,methods3);

9758
          ssSetModelMethods3(childS, methods3);

9759
        }

9760


9761
        /* Allocate memory for states auxilliary information */

9762
        {

9763
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

9764
            (sizeof(struct _ssStatesInfo2));

9765
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

9766
            malloc(sizeof(ssPeriodicStatesInfo));

9767
          ss_VALIDATE_MEMORY(rts,statesInfo2);

9768
          ssSetStatesInfo2(childS, statesInfo2);

9769
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

9770
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

9771
        }

9772


9773
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

9774
          RegNumInputPorts);

9775
        ssSetRegNumInputPortsFcnArg(childS,childS);

9776


9777
        /* inputs */

9778
        {

9779
          struct _ssPortInputs *inputPortInfo =

9780
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

9781
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

9782
          _ssSetNumInputPorts(childS, 2);

9783
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

9784


9785
          /* port 0 */

9786
          {

9787
            real32_T const **sfcnUPtrs = (real32_T const **)

9788
              malloc(1 * sizeof(real32_T *));

9789
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9790
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

9791
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_n;

9792
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

9793
            _ssSetInputPortNumDimensions(childS, 0, 1);

9794
            ssSetInputPortWidth(childS, 0, 1);

9795
          }

9796


9797
          /* port 1 */

9798
          {

9799
            real32_T const **sfcnUPtrs = (real32_T const **)

9800
              malloc(1 * sizeof(real32_T *));

9801
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

9802
            sfcnUPtrs[0] = (real32_T const *)

9803
              &AFCS_MODEL1_ConstP.Constant13_Value_n;

9804
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

9805
            _ssSetInputPortNumDimensions(childS, 1, 1);

9806
            ssSetInputPortWidth(childS, 1, 1);

9807
          }

9808
        }

9809


9810
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

9811
          RegNumOutputPorts);

9812
        ssSetRegNumOutputPortsFcnArg(childS,childS);

9813


9814
        /* outputs */

9815
        {

9816
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

9817
            calloc(1, sizeof(struct _ssPortOutputs));

9818
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

9819
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

9820
          _ssSetNumOutputPorts(childS, 1);

9821


9822
          /* port 0 */

9823
          {

9824
            _ssSetOutputPortNumDimensions(childS, 0, 1);

9825
            ssSetOutputPortWidth(childS, 0, 1);

9826
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

9827
              ssGetLocalBlockIO(rts))->GeneratedSFunction_b1));

9828
          }

9829
        }

9830


9831
        /* path info */

9832
        _ssSetModelName(childS, "Gain_sf");

9833
        _ssSetPath(childS,

9834
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/gain/Generated S-Function");

9835
        if (ssGetRTModel(rts) == (NULL)) {

9836
          _ssSetParentSS(childS, rts);

9837
          _ssSetRootSS(childS, ssGetRootSS(rts));

9838
        } else {

9839
          ssSetRTModel(childS,ssGetRTModel(rts));

9840
          _ssSetParentSS(childS, (NULL));

9841
          _ssSetRootSS(childS, childS);

9842
        }

9843


9844
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

9845
        (childS)->regDataType.arg1 = ((void *)(childS));

9846
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

9847
          FcnSetErrorStatus);

9848
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

9849
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

9850
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

9851
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

9852


9853
        /* registration */

9854
#if defined(MATLAB_MEX_FILE)

9855


9856
        {

9857
          int_T i;

9858
          mxArray *plhs[1];

9859
          mxArray *prhs[4];

9860
          double *pr;

9861
          volatile int_T *intS = (int_T *)&childS;

9862
          int_T addrlen = sizeof(SimStruct *);

9863
          int_T m = addrlen/sizeof(int_T) + 1;

9864
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

9865
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

9866
          pr = mxGetPr(prhs[1]);

9867
          for (i = 0; i < m - 1; i++) {

9868
            pr[i] = (double)intS[i];

9869
          }

9870


9871
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

9872
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

9873
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

9874


9875
          /* Reset port dimensions info functions because the S-function

9876
           * and accelerator mex-files explicitly set their dimensions,

9877
           * i.e., they are not dynamically sized. For this case, the

9878
           * mex-file is responsible for the dimensions info memory

9879
           * and Simulink should not free it. This is achieved by

9880
           * setting the following two methods to NULL.

9881
           */

9882
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

9883
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

9884


9885
          /*

9886
           * Setup function pointers and call mdlInitializeSizes via

9887
           * simulink.c

9888
           */

9889
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

9890
          mxDestroyArray(plhs[0]);

9891
          mxDestroyArray(prhs[0]);

9892
          mxDestroyArray(prhs[1]);

9893
          mxDestroyArray(prhs[2]);

9894
          mxDestroyArray(prhs[3]);

9895
        }

9896


9897
#else

9898


9899
        {

9900
          Gain_sf(childS);

9901
          sfcnInitializeSizes(childS);

9902
        }

9903


9904
#endif

9905


9906
        sfcnInitializeSampleTimes(childS);

9907


9908
        /* adjust sample time */

9909
        ssSetSampleTime(childS, 0, 0.0);

9910
        ssSetOffsetTime(childS, 0, 0.0);

9911
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

9912


9913
        /* set compiled values of dynamic vector attributes */

9914
        ssSetNumNonsampledZCs(childS, 0);

9915


9916
        /* Update connectivity flags for each port */

9917
        _ssSetInputPortConnected(childS, 0, 1);

9918
        _ssSetInputPortConnected(childS, 1, 1);

9919
        _ssSetOutputPortConnected(childS, 0, 1);

9920
        _ssSetOutputPortBeingMerged(childS, 0, 0);

9921


9922
        /* Update the BufferDstPort flags for each input port */

9923
        _ssSetInputPortBufferDstPort(childS, 0, -1);

9924
        _ssSetInputPortBufferDstPort(childS, 1, -1);

9925
      }

9926


9927
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S105>/Generated S-Function (Gain_sf) */

9928
      {

9929
        SimStruct *childS = ssGetSFunction(rts, 37);

9930


9931
        /* timing info */

9932
        time_T *sfcnPeriod;

9933
        time_T *sfcnOffset;

9934
        int_T *sfcnTsMap;

9935
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

9936
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

9937
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

9938
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

9939
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

9940
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

9941
        (void) memset((void*)sfcnPeriod, 0,

9942
                      sizeof(time_T)*1);

9943
        (void) memset((void*)sfcnOffset, 0,

9944
                      sizeof(time_T)*1);

9945
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

9946
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

9947
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

9948


9949
        /* Set up the mdlInfo pointer */

9950
# ifdef USE_RTMODEL

9951


9952
        {

9953
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

9954
              struct _ssBlkInfo2));

9955
          ss_VALIDATE_MEMORY(rts,blkInfo2);

9956
          ssSetBlkInfo2Ptr(childS, blkInfo2);

9957
        }

9958


9959
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

9960


9961
# else

9962


9963
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

9964


9965
# endif                                /* USE_RTMODEL */

9966


9967
        /* Allocate memory of model methods 2 */

9968
        {

9969
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

9970
            malloc(sizeof(struct _ssSFcnModelMethods2));

9971
          ss_VALIDATE_MEMORY(rts,methods2);

9972
          ssSetModelMethods2(childS, methods2);

9973
        }

9974


9975
        /* Allocate memory of model methods 3 */

9976
        {

9977
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

9978
            malloc(sizeof(struct _ssSFcnModelMethods3));

9979
          ss_VALIDATE_MEMORY(rts,methods3);

9980
          ssSetModelMethods3(childS, methods3);

9981
        }

9982


9983
        /* Allocate memory for states auxilliary information */

9984
        {

9985
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

9986
            (sizeof(struct _ssStatesInfo2));

9987
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

9988
            malloc(sizeof(ssPeriodicStatesInfo));

9989
          ss_VALIDATE_MEMORY(rts,statesInfo2);

9990
          ssSetStatesInfo2(childS, statesInfo2);

9991
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

9992
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

9993
        }

9994


9995
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

9996
          RegNumInputPorts);

9997
        ssSetRegNumInputPortsFcnArg(childS,childS);

9998


9999
        /* inputs */

10000
        {

10001
          struct _ssPortInputs *inputPortInfo =

10002
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

10003
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

10004
          _ssSetNumInputPorts(childS, 2);

10005
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

10006


10007
          /* port 0 */

10008
          {

10009
            real32_T const **sfcnUPtrs = (real32_T const **)

10010
              malloc(1 * sizeof(real32_T *));

10011
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10012
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10013
              ssGetLocalBlockIO(rts))->GeneratedSFunction_b1;

10014
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

10015
            _ssSetInputPortNumDimensions(childS, 0, 1);

10016
            ssSetInputPortWidth(childS, 0, 1);

10017
          }

10018


10019
          /* port 1 */

10020
          {

10021
            real32_T const **sfcnUPtrs = (real32_T const **)

10022
              malloc(1 * sizeof(real32_T *));

10023
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10024
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

10025
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

10026
            _ssSetInputPortNumDimensions(childS, 1, 1);

10027
            ssSetInputPortWidth(childS, 1, 1);

10028
          }

10029
        }

10030


10031
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

10032
          RegNumOutputPorts);

10033
        ssSetRegNumOutputPortsFcnArg(childS,childS);

10034


10035
        /* outputs */

10036
        {

10037
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

10038
            calloc(1, sizeof(struct _ssPortOutputs));

10039
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

10040
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

10041
          _ssSetNumOutputPorts(childS, 1);

10042


10043
          /* port 0 */

10044
          {

10045
            _ssSetOutputPortNumDimensions(childS, 0, 1);

10046
            ssSetOutputPortWidth(childS, 0, 1);

10047
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

10048
              ssGetLocalBlockIO(rts))->GeneratedSFunction_h));

10049
          }

10050
        }

10051


10052
        /* path info */

10053
        _ssSetModelName(childS, "Gain_sf");

10054
        _ssSetPath(childS,

10055
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/gain4/Generated S-Function");

10056
        if (ssGetRTModel(rts) == (NULL)) {

10057
          _ssSetParentSS(childS, rts);

10058
          _ssSetRootSS(childS, ssGetRootSS(rts));

10059
        } else {

10060
          ssSetRTModel(childS,ssGetRTModel(rts));

10061
          _ssSetParentSS(childS, (NULL));

10062
          _ssSetRootSS(childS, childS);

10063
        }

10064


10065
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

10066
        (childS)->regDataType.arg1 = ((void *)(childS));

10067
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

10068
          FcnSetErrorStatus);

10069
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

10070
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

10071
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

10072
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

10073


10074
        /* registration */

10075
#if defined(MATLAB_MEX_FILE)

10076


10077
        {

10078
          int_T i;

10079
          mxArray *plhs[1];

10080
          mxArray *prhs[4];

10081
          double *pr;

10082
          volatile int_T *intS = (int_T *)&childS;

10083
          int_T addrlen = sizeof(SimStruct *);

10084
          int_T m = addrlen/sizeof(int_T) + 1;

10085
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

10086
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

10087
          pr = mxGetPr(prhs[1]);

10088
          for (i = 0; i < m - 1; i++) {

10089
            pr[i] = (double)intS[i];

10090
          }

10091


10092
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

10093
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

10094
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

10095


10096
          /* Reset port dimensions info functions because the S-function

10097
           * and accelerator mex-files explicitly set their dimensions,

10098
           * i.e., they are not dynamically sized. For this case, the

10099
           * mex-file is responsible for the dimensions info memory

10100
           * and Simulink should not free it. This is achieved by

10101
           * setting the following two methods to NULL.

10102
           */

10103
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

10104
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

10105


10106
          /*

10107
           * Setup function pointers and call mdlInitializeSizes via

10108
           * simulink.c

10109
           */

10110
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

10111
          mxDestroyArray(plhs[0]);

10112
          mxDestroyArray(prhs[0]);

10113
          mxDestroyArray(prhs[1]);

10114
          mxDestroyArray(prhs[2]);

10115
          mxDestroyArray(prhs[3]);

10116
        }

10117


10118
#else

10119


10120
        {

10121
          Gain_sf(childS);

10122
          sfcnInitializeSizes(childS);

10123
        }

10124


10125
#endif

10126


10127
        sfcnInitializeSampleTimes(childS);

10128


10129
        /* adjust sample time */

10130
        ssSetSampleTime(childS, 0, 0.0);

10131
        ssSetOffsetTime(childS, 0, 0.0);

10132
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

10133


10134
        /* set compiled values of dynamic vector attributes */

10135
        ssSetNumNonsampledZCs(childS, 0);

10136


10137
        /* Update connectivity flags for each port */

10138
        _ssSetInputPortConnected(childS, 0, 1);

10139
        _ssSetInputPortConnected(childS, 1, 1);

10140
        _ssSetOutputPortConnected(childS, 0, 1);

10141
        _ssSetOutputPortBeingMerged(childS, 0, 0);

10142


10143
        /* Update the BufferDstPort flags for each input port */

10144
        _ssSetInputPortBufferDstPort(childS, 0, -1);

10145
        _ssSetInputPortBufferDstPort(childS, 1, -1);

10146
      }

10147


10148
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S100>/Generated S-Function3 (IntegratorLimited_sf) */

10149
      {

10150
        SimStruct *childS = ssGetSFunction(rts, 38);

10151


10152
        /* timing info */

10153
        time_T *sfcnPeriod;

10154
        time_T *sfcnOffset;

10155
        int_T *sfcnTsMap;

10156
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

10157
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

10158
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

10159
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

10160
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

10161
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

10162
        (void) memset((void*)sfcnPeriod, 0,

10163
                      sizeof(time_T)*1);

10164
        (void) memset((void*)sfcnOffset, 0,

10165
                      sizeof(time_T)*1);

10166
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

10167
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

10168
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

10169


10170
        /* Set up the mdlInfo pointer */

10171
# ifdef USE_RTMODEL

10172


10173
        {

10174
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

10175
              struct _ssBlkInfo2));

10176
          ss_VALIDATE_MEMORY(rts,blkInfo2);

10177
          ssSetBlkInfo2Ptr(childS, blkInfo2);

10178
        }

10179


10180
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

10181


10182
# else

10183


10184
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

10185


10186
# endif                                /* USE_RTMODEL */

10187


10188
        /* Allocate memory of model methods 2 */

10189
        {

10190
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

10191
            malloc(sizeof(struct _ssSFcnModelMethods2));

10192
          ss_VALIDATE_MEMORY(rts,methods2);

10193
          ssSetModelMethods2(childS, methods2);

10194
        }

10195


10196
        /* Allocate memory of model methods 3 */

10197
        {

10198
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

10199
            malloc(sizeof(struct _ssSFcnModelMethods3));

10200
          ss_VALIDATE_MEMORY(rts,methods3);

10201
          ssSetModelMethods3(childS, methods3);

10202
        }

10203


10204
        /* Allocate memory for states auxilliary information */

10205
        {

10206
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

10207
            (sizeof(struct _ssStatesInfo2));

10208
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

10209
            malloc(sizeof(ssPeriodicStatesInfo));

10210
          ss_VALIDATE_MEMORY(rts,statesInfo2);

10211
          ssSetStatesInfo2(childS, statesInfo2);

10212
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

10213
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

10214
        }

10215


10216
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

10217
          RegNumInputPorts);

10218
        ssSetRegNumInputPortsFcnArg(childS,childS);

10219


10220
        /* inputs */

10221
        {

10222
          struct _ssPortInputs *inputPortInfo =

10223
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

10224
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

10225
          _ssSetNumInputPorts(childS, 7);

10226
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

10227


10228
          /* port 0 */

10229
          {

10230
            real32_T const **sfcnUPtrs = (real32_T const **)

10231
              malloc(1 * sizeof(real32_T *));

10232
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10233
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10234
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

10235
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

10236
            _ssSetInputPortNumDimensions(childS, 0, 1);

10237
            ssSetInputPortWidth(childS, 0, 1);

10238
          }

10239


10240
          /* port 1 */

10241
          {

10242
            int8_T const **sfcnUPtrs = (int8_T const **)

10243
              malloc(1 * sizeof(int8_T *));

10244
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10245
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

10246
              ssGetLocalBlockIO(rts))->DataTypeConversion2_c;

10247
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

10248
            _ssSetInputPortNumDimensions(childS, 1, 1);

10249
            ssSetInputPortWidth(childS, 1, 1);

10250
          }

10251


10252
          /* port 2 */

10253
          {

10254
            real32_T const **sfcnUPtrs = (real32_T const **)

10255
              malloc(1 * sizeof(real32_T *));

10256
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10257
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

10258
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

10259
            _ssSetInputPortNumDimensions(childS, 2, 1);

10260
            ssSetInputPortWidth(childS, 2, 1);

10261
          }

10262


10263
          /* port 3 */

10264
          {

10265
            real32_T const **sfcnUPtrs = (real32_T const **)

10266
              malloc(1 * sizeof(real32_T *));

10267
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10268
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

10269
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

10270
            _ssSetInputPortNumDimensions(childS, 3, 1);

10271
            ssSetInputPortWidth(childS, 3, 1);

10272
          }

10273


10274
          /* port 4 */

10275
          {

10276
            real32_T const **sfcnUPtrs = (real32_T const **)

10277
              malloc(1 * sizeof(real32_T *));

10278
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10279
            sfcnUPtrs[0] = (real32_T const *)

10280
              &AFCS_MODEL1_ConstP.Constant19_Value;

10281
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

10282
            _ssSetInputPortNumDimensions(childS, 4, 1);

10283
            ssSetInputPortWidth(childS, 4, 1);

10284
          }

10285


10286
          /* port 5 */

10287
          {

10288
            real32_T const **sfcnUPtrs = (real32_T const **)

10289
              malloc(1 * sizeof(real32_T *));

10290
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10291
            sfcnUPtrs[0] = (real32_T const *)

10292
              &AFCS_MODEL1_ConstP.Constant76_Value;

10293
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

10294
            _ssSetInputPortNumDimensions(childS, 5, 1);

10295
            ssSetInputPortWidth(childS, 5, 1);

10296
          }

10297


10298
          /* port 6 */

10299
          {

10300
            real32_T const **sfcnUPtrs = (real32_T const **)

10301
              malloc(1 * sizeof(real32_T *));

10302
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10303
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10304
              ssGetLocalBlockIO(rts))->GeneratedSFunction_h;

10305
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

10306
            _ssSetInputPortNumDimensions(childS, 6, 1);

10307
            ssSetInputPortWidth(childS, 6, 1);

10308
          }

10309
        }

10310


10311
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

10312
          RegNumOutputPorts);

10313
        ssSetRegNumOutputPortsFcnArg(childS,childS);

10314


10315
        /* outputs */

10316
        {

10317
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

10318
            calloc(1, sizeof(struct _ssPortOutputs));

10319
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

10320
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

10321
          _ssSetNumOutputPorts(childS, 1);

10322


10323
          /* port 0 */

10324
          {

10325
            _ssSetOutputPortNumDimensions(childS, 0, 1);

10326
            ssSetOutputPortWidth(childS, 0, 1);

10327
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

10328
              ssGetLocalBlockIO(rts))->Saturation8));

10329
          }

10330
        }

10331


10332
        /* path info */

10333
        _ssSetModelName(childS, "IntegratorLimited_sf");

10334
        _ssSetPath(childS,

10335
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Integrator Limited1/Generated S-Function3");

10336
        if (ssGetRTModel(rts) == (NULL)) {

10337
          _ssSetParentSS(childS, rts);

10338
          _ssSetRootSS(childS, ssGetRootSS(rts));

10339
        } else {

10340
          ssSetRTModel(childS,ssGetRTModel(rts));

10341
          _ssSetParentSS(childS, (NULL));

10342
          _ssSetRootSS(childS, childS);

10343
        }

10344


10345
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

10346


10347
        /* work vectors */

10348
        {

10349
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

10350
            (4 * sizeof(struct _ssDWorkRecord));

10351
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

10352
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

10353
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

10354
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

10355
          ssSetSFcnDWork(childS, dWorkRecord);

10356
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

10357
          _ssSetNumDWork(childS, 4);

10358


10359
          /* DWORK0 */

10360
          ssSetDWorkWidth(childS, 0, 1);

10361
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

10362
          ssSetDWorkComplexSignal(childS, 0, 0);

10363
          ssSetDWorkUsedAsDState(childS, 0, 1);

10364
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 176))[0]);

10365


10366
          /* DWORK1 */

10367
          ssSetDWorkWidth(childS, 1, 1);

10368
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

10369
          ssSetDWorkComplexSignal(childS, 1, 0);

10370
          ssSetDWorkUsedAsDState(childS, 1, 1);

10371
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 177))[0]);

10372


10373
          /* DWORK2 */

10374
          ssSetDWorkWidth(childS, 2, 1);

10375
          ssSetDWorkDataType(childS, 2,SS_INT8);

10376
          ssSetDWorkComplexSignal(childS, 2, 0);

10377
          ssSetDWorkUsedAsDState(childS, 2, 1);

10378
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 403))[0]);

10379


10380
          /* DWORK3 */

10381
          ssSetDWorkWidth(childS, 3, 1);

10382
          ssSetDWorkDataType(childS, 3,SS_INT8);

10383
          ssSetDWorkComplexSignal(childS, 3, 0);

10384
          ssSetDWorkUsedAsDState(childS, 3, 1);

10385
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 404))[0]);

10386
        }

10387


10388
        (childS)->regDataType.arg1 = ((void *)(childS));

10389
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

10390
          FcnSetErrorStatus);

10391
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

10392
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

10393
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

10394
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

10395


10396
        /* registration */

10397
#if defined(MATLAB_MEX_FILE)

10398


10399
        {

10400
          int_T i;

10401
          mxArray *plhs[1];

10402
          mxArray *prhs[4];

10403
          double *pr;

10404
          volatile int_T *intS = (int_T *)&childS;

10405
          int_T addrlen = sizeof(SimStruct *);

10406
          int_T m = addrlen/sizeof(int_T) + 1;

10407
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

10408
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

10409
          pr = mxGetPr(prhs[1]);

10410
          for (i = 0; i < m - 1; i++) {

10411
            pr[i] = (double)intS[i];

10412
          }

10413


10414
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

10415
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

10416
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

10417


10418
          /* Reset port dimensions info functions because the S-function

10419
           * and accelerator mex-files explicitly set their dimensions,

10420
           * i.e., they are not dynamically sized. For this case, the

10421
           * mex-file is responsible for the dimensions info memory

10422
           * and Simulink should not free it. This is achieved by

10423
           * setting the following two methods to NULL.

10424
           */

10425
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

10426
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

10427


10428
          /*

10429
           * Setup function pointers and call mdlInitializeSizes via

10430
           * simulink.c

10431
           */

10432
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

10433
          mxDestroyArray(plhs[0]);

10434
          mxDestroyArray(prhs[0]);

10435
          mxDestroyArray(prhs[1]);

10436
          mxDestroyArray(prhs[2]);

10437
          mxDestroyArray(prhs[3]);

10438
        }

10439


10440
#else

10441


10442
        {

10443
          IntegratorLimited_sf(childS);

10444
          sfcnInitializeSizes(childS);

10445
        }

10446


10447
#endif

10448


10449
        sfcnInitializeSampleTimes(childS);

10450


10451
        /* adjust sample time */

10452
        ssSetSampleTime(childS, 0, 0.0);

10453
        ssSetOffsetTime(childS, 0, 0.0);

10454
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

10455


10456
        /* set compiled values of dynamic vector attributes */

10457
        ssSetNumNonsampledZCs(childS, 0);

10458


10459
        /* Update connectivity flags for each port */

10460
        _ssSetInputPortConnected(childS, 0, 1);

10461
        _ssSetInputPortConnected(childS, 1, 1);

10462
        _ssSetInputPortConnected(childS, 2, 1);

10463
        _ssSetInputPortConnected(childS, 3, 1);

10464
        _ssSetInputPortConnected(childS, 4, 1);

10465
        _ssSetInputPortConnected(childS, 5, 1);

10466
        _ssSetInputPortConnected(childS, 6, 1);

10467
        _ssSetOutputPortConnected(childS, 0, 1);

10468
        _ssSetOutputPortBeingMerged(childS, 0, 0);

10469


10470
        /* Update the BufferDstPort flags for each input port */

10471
        _ssSetInputPortBufferDstPort(childS, 0, -1);

10472
        _ssSetInputPortBufferDstPort(childS, 1, -1);

10473
        _ssSetInputPortBufferDstPort(childS, 2, -1);

10474
        _ssSetInputPortBufferDstPort(childS, 3, -1);

10475
        _ssSetInputPortBufferDstPort(childS, 4, -1);

10476
        _ssSetInputPortBufferDstPort(childS, 5, -1);

10477
        _ssSetInputPortBufferDstPort(childS, 6, -1);

10478
      }

10479


10480
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S101>/Generated S-Function2 (LeadLagFilter_sf) */

10481
      {

10482
        SimStruct *childS = ssGetSFunction(rts, 39);

10483


10484
        /* timing info */

10485
        time_T *sfcnPeriod;

10486
        time_T *sfcnOffset;

10487
        int_T *sfcnTsMap;

10488
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

10489
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

10490
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

10491
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

10492
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

10493
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

10494
        (void) memset((void*)sfcnPeriod, 0,

10495
                      sizeof(time_T)*1);

10496
        (void) memset((void*)sfcnOffset, 0,

10497
                      sizeof(time_T)*1);

10498
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

10499
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

10500
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

10501


10502
        /* Set up the mdlInfo pointer */

10503
# ifdef USE_RTMODEL

10504


10505
        {

10506
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

10507
              struct _ssBlkInfo2));

10508
          ss_VALIDATE_MEMORY(rts,blkInfo2);

10509
          ssSetBlkInfo2Ptr(childS, blkInfo2);

10510
        }

10511


10512
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

10513


10514
# else

10515


10516
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

10517


10518
# endif                                /* USE_RTMODEL */

10519


10520
        /* Allocate memory of model methods 2 */

10521
        {

10522
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

10523
            malloc(sizeof(struct _ssSFcnModelMethods2));

10524
          ss_VALIDATE_MEMORY(rts,methods2);

10525
          ssSetModelMethods2(childS, methods2);

10526
        }

10527


10528
        /* Allocate memory of model methods 3 */

10529
        {

10530
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

10531
            malloc(sizeof(struct _ssSFcnModelMethods3));

10532
          ss_VALIDATE_MEMORY(rts,methods3);

10533
          ssSetModelMethods3(childS, methods3);

10534
        }

10535


10536
        /* Allocate memory for states auxilliary information */

10537
        {

10538
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

10539
            (sizeof(struct _ssStatesInfo2));

10540
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

10541
            malloc(sizeof(ssPeriodicStatesInfo));

10542
          ss_VALIDATE_MEMORY(rts,statesInfo2);

10543
          ssSetStatesInfo2(childS, statesInfo2);

10544
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

10545
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

10546
        }

10547


10548
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

10549
          RegNumInputPorts);

10550
        ssSetRegNumInputPortsFcnArg(childS,childS);

10551


10552
        /* inputs */

10553
        {

10554
          struct _ssPortInputs *inputPortInfo =

10555
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

10556
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

10557
          _ssSetNumInputPorts(childS, 7);

10558
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

10559


10560
          /* port 0 */

10561
          {

10562
            real32_T const **sfcnUPtrs = (real32_T const **)

10563
              malloc(1 * sizeof(real32_T *));

10564
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10565
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10566
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

10567
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

10568
            _ssSetInputPortNumDimensions(childS, 0, 1);

10569
            ssSetInputPortWidth(childS, 0, 1);

10570
          }

10571


10572
          /* port 1 */

10573
          {

10574
            int8_T const **sfcnUPtrs = (int8_T const **)

10575
              malloc(1 * sizeof(int8_T *));

10576
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10577
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

10578
              ssGetLocalBlockIO(rts))->DataTypeConversion2_c;

10579
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

10580
            _ssSetInputPortNumDimensions(childS, 1, 1);

10581
            ssSetInputPortWidth(childS, 1, 1);

10582
          }

10583


10584
          /* port 2 */

10585
          {

10586
            real32_T const **sfcnUPtrs = (real32_T const **)

10587
              malloc(1 * sizeof(real32_T *));

10588
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10589
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

10590
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

10591
            _ssSetInputPortNumDimensions(childS, 2, 1);

10592
            ssSetInputPortWidth(childS, 2, 1);

10593
          }

10594


10595
          /* port 3 */

10596
          {

10597
            real32_T const **sfcnUPtrs = (real32_T const **)

10598
              malloc(1 * sizeof(real32_T *));

10599
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10600
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;

10601
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

10602
            _ssSetInputPortNumDimensions(childS, 3, 1);

10603
            ssSetInputPortWidth(childS, 3, 1);

10604
          }

10605


10606
          /* port 4 */

10607
          {

10608
            real32_T const **sfcnUPtrs = (real32_T const **)

10609
              malloc(1 * sizeof(real32_T *));

10610
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10611
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10612
              ssGetLocalBlockIO(rts))->Switch_aj;

10613
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

10614
            _ssSetInputPortNumDimensions(childS, 4, 1);

10615
            ssSetInputPortWidth(childS, 4, 1);

10616
          }

10617


10618
          /* port 5 */

10619
          {

10620
            real32_T const **sfcnUPtrs = (real32_T const **)

10621
              malloc(1 * sizeof(real32_T *));

10622
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10623
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10624
              ssGetLocalBlockIO(rts))->Switch_aj;

10625
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

10626
            _ssSetInputPortNumDimensions(childS, 5, 1);

10627
            ssSetInputPortWidth(childS, 5, 1);

10628
          }

10629


10630
          /* port 6 */

10631
          {

10632
            real32_T const **sfcnUPtrs = (real32_T const **)

10633
              malloc(1 * sizeof(real32_T *));

10634
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10635
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10636
              ssGetLocalBlockIO(rts))->Divide_e;

10637
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

10638
            _ssSetInputPortNumDimensions(childS, 6, 1);

10639
            ssSetInputPortWidth(childS, 6, 1);

10640
          }

10641
        }

10642


10643
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

10644
          RegNumOutputPorts);

10645
        ssSetRegNumOutputPortsFcnArg(childS,childS);

10646


10647
        /* outputs */

10648
        {

10649
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

10650
            calloc(1, sizeof(struct _ssPortOutputs));

10651
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

10652
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

10653
          _ssSetNumOutputPorts(childS, 1);

10654


10655
          /* port 0 */

10656
          {

10657
            _ssSetOutputPortNumDimensions(childS, 0, 1);

10658
            ssSetOutputPortWidth(childS, 0, 1);

10659
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

10660
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_j));

10661
          }

10662
        }

10663


10664
        /* path info */

10665
        _ssSetModelName(childS, "LeadLagFilter_sf");

10666
        _ssSetPath(childS,

10667
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Lead lag/Generated S-Function2");

10668
        if (ssGetRTModel(rts) == (NULL)) {

10669
          _ssSetParentSS(childS, rts);

10670
          _ssSetRootSS(childS, ssGetRootSS(rts));

10671
        } else {

10672
          ssSetRTModel(childS,ssGetRTModel(rts));

10673
          _ssSetParentSS(childS, (NULL));

10674
          _ssSetRootSS(childS, childS);

10675
        }

10676


10677
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

10678


10679
        /* work vectors */

10680
        {

10681
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

10682
            (4 * sizeof(struct _ssDWorkRecord));

10683
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

10684
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

10685
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

10686
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

10687
          ssSetSFcnDWork(childS, dWorkRecord);

10688
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

10689
          _ssSetNumDWork(childS, 4);

10690


10691
          /* DWORK0 */

10692
          ssSetDWorkWidth(childS, 0, 1);

10693
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

10694
          ssSetDWorkComplexSignal(childS, 0, 0);

10695
          ssSetDWorkUsedAsDState(childS, 0, 1);

10696
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 178))[0]);

10697


10698
          /* DWORK1 */

10699
          ssSetDWorkWidth(childS, 1, 1);

10700
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

10701
          ssSetDWorkComplexSignal(childS, 1, 0);

10702
          ssSetDWorkUsedAsDState(childS, 1, 1);

10703
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 179))[0]);

10704


10705
          /* DWORK2 */

10706
          ssSetDWorkWidth(childS, 2, 1);

10707
          ssSetDWorkDataType(childS, 2,SS_INT8);

10708
          ssSetDWorkComplexSignal(childS, 2, 0);

10709
          ssSetDWorkUsedAsDState(childS, 2, 1);

10710
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 405))[0]);

10711


10712
          /* DWORK3 */

10713
          ssSetDWorkWidth(childS, 3, 1);

10714
          ssSetDWorkDataType(childS, 3,SS_INT8);

10715
          ssSetDWorkComplexSignal(childS, 3, 0);

10716
          ssSetDWorkUsedAsDState(childS, 3, 1);

10717
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 406))[0]);

10718
        }

10719


10720
        (childS)->regDataType.arg1 = ((void *)(childS));

10721
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

10722
          FcnSetErrorStatus);

10723
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

10724
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

10725
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

10726
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

10727


10728
        /* registration */

10729
#if defined(MATLAB_MEX_FILE)

10730


10731
        {

10732
          int_T i;

10733
          mxArray *plhs[1];

10734
          mxArray *prhs[4];

10735
          double *pr;

10736
          volatile int_T *intS = (int_T *)&childS;

10737
          int_T addrlen = sizeof(SimStruct *);

10738
          int_T m = addrlen/sizeof(int_T) + 1;

10739
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

10740
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

10741
          pr = mxGetPr(prhs[1]);

10742
          for (i = 0; i < m - 1; i++) {

10743
            pr[i] = (double)intS[i];

10744
          }

10745


10746
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

10747
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

10748
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

10749


10750
          /* Reset port dimensions info functions because the S-function

10751
           * and accelerator mex-files explicitly set their dimensions,

10752
           * i.e., they are not dynamically sized. For this case, the

10753
           * mex-file is responsible for the dimensions info memory

10754
           * and Simulink should not free it. This is achieved by

10755
           * setting the following two methods to NULL.

10756
           */

10757
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

10758
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

10759


10760
          /*

10761
           * Setup function pointers and call mdlInitializeSizes via

10762
           * simulink.c

10763
           */

10764
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

10765
          mxDestroyArray(plhs[0]);

10766
          mxDestroyArray(prhs[0]);

10767
          mxDestroyArray(prhs[1]);

10768
          mxDestroyArray(prhs[2]);

10769
          mxDestroyArray(prhs[3]);

10770
        }

10771


10772
#else

10773


10774
        {

10775
          LeadLagFilter_sf(childS);

10776
          sfcnInitializeSizes(childS);

10777
        }

10778


10779
#endif

10780


10781
        sfcnInitializeSampleTimes(childS);

10782


10783
        /* adjust sample time */

10784
        ssSetSampleTime(childS, 0, 0.0);

10785
        ssSetOffsetTime(childS, 0, 0.0);

10786
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

10787


10788
        /* set compiled values of dynamic vector attributes */

10789
        ssSetNumNonsampledZCs(childS, 0);

10790


10791
        /* Update connectivity flags for each port */

10792
        _ssSetInputPortConnected(childS, 0, 1);

10793
        _ssSetInputPortConnected(childS, 1, 1);

10794
        _ssSetInputPortConnected(childS, 2, 1);

10795
        _ssSetInputPortConnected(childS, 3, 1);

10796
        _ssSetInputPortConnected(childS, 4, 1);

10797
        _ssSetInputPortConnected(childS, 5, 1);

10798
        _ssSetInputPortConnected(childS, 6, 1);

10799
        _ssSetOutputPortConnected(childS, 0, 1);

10800
        _ssSetOutputPortBeingMerged(childS, 0, 0);

10801


10802
        /* Update the BufferDstPort flags for each input port */

10803
        _ssSetInputPortBufferDstPort(childS, 0, -1);

10804
        _ssSetInputPortBufferDstPort(childS, 1, -1);

10805
        _ssSetInputPortBufferDstPort(childS, 2, -1);

10806
        _ssSetInputPortBufferDstPort(childS, 3, -1);

10807
        _ssSetInputPortBufferDstPort(childS, 4, -1);

10808
        _ssSetInputPortBufferDstPort(childS, 5, -1);

10809
        _ssSetInputPortBufferDstPort(childS, 6, -1);

10810
      }

10811


10812
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S103>/Generated S-Function1 (SaturationLimiter_sf) */

10813
      {

10814
        SimStruct *childS = ssGetSFunction(rts, 40);

10815


10816
        /* timing info */

10817
        time_T *sfcnPeriod;

10818
        time_T *sfcnOffset;

10819
        int_T *sfcnTsMap;

10820
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

10821
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

10822
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

10823
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

10824
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

10825
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

10826
        (void) memset((void*)sfcnPeriod, 0,

10827
                      sizeof(time_T)*1);

10828
        (void) memset((void*)sfcnOffset, 0,

10829
                      sizeof(time_T)*1);

10830
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

10831
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

10832
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

10833


10834
        /* Set up the mdlInfo pointer */

10835
# ifdef USE_RTMODEL

10836


10837
        {

10838
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

10839
              struct _ssBlkInfo2));

10840
          ss_VALIDATE_MEMORY(rts,blkInfo2);

10841
          ssSetBlkInfo2Ptr(childS, blkInfo2);

10842
        }

10843


10844
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

10845


10846
# else

10847


10848
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

10849


10850
# endif                                /* USE_RTMODEL */

10851


10852
        /* Allocate memory of model methods 2 */

10853
        {

10854
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

10855
            malloc(sizeof(struct _ssSFcnModelMethods2));

10856
          ss_VALIDATE_MEMORY(rts,methods2);

10857
          ssSetModelMethods2(childS, methods2);

10858
        }

10859


10860
        /* Allocate memory of model methods 3 */

10861
        {

10862
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

10863
            malloc(sizeof(struct _ssSFcnModelMethods3));

10864
          ss_VALIDATE_MEMORY(rts,methods3);

10865
          ssSetModelMethods3(childS, methods3);

10866
        }

10867


10868
        /* Allocate memory for states auxilliary information */

10869
        {

10870
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

10871
            (sizeof(struct _ssStatesInfo2));

10872
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

10873
            malloc(sizeof(ssPeriodicStatesInfo));

10874
          ss_VALIDATE_MEMORY(rts,statesInfo2);

10875
          ssSetStatesInfo2(childS, statesInfo2);

10876
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

10877
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

10878
        }

10879


10880
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

10881
          RegNumInputPorts);

10882
        ssSetRegNumInputPortsFcnArg(childS,childS);

10883


10884
        /* inputs */

10885
        {

10886
          struct _ssPortInputs *inputPortInfo =

10887
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

10888
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

10889
          _ssSetNumInputPorts(childS, 3);

10890
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

10891


10892
          /* port 0 */

10893
          {

10894
            real32_T const **sfcnUPtrs = (real32_T const **)

10895
              malloc(1 * sizeof(real32_T *));

10896
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10897
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10898
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_j;

10899
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

10900
            _ssSetInputPortNumDimensions(childS, 0, 1);

10901
            ssSetInputPortWidth(childS, 0, 1);

10902
          }

10903


10904
          /* port 1 */

10905
          {

10906
            real32_T const **sfcnUPtrs = (real32_T const **)

10907
              malloc(1 * sizeof(real32_T *));

10908
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10909
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10910
              ssGetLocalBlockIO(rts))->Product1_m;

10911
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

10912
            _ssSetInputPortNumDimensions(childS, 1, 1);

10913
            ssSetInputPortWidth(childS, 1, 1);

10914
          }

10915


10916
          /* port 2 */

10917
          {

10918
            real32_T const **sfcnUPtrs = (real32_T const **)

10919
              malloc(1 * sizeof(real32_T *));

10920
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

10921
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

10922
              ssGetLocalBlockIO(rts))->Product_pp;

10923
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

10924
            _ssSetInputPortNumDimensions(childS, 2, 1);

10925
            ssSetInputPortWidth(childS, 2, 1);

10926
          }

10927
        }

10928


10929
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

10930
          RegNumOutputPorts);

10931
        ssSetRegNumOutputPortsFcnArg(childS,childS);

10932


10933
        /* outputs */

10934
        {

10935
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

10936
            calloc(1, sizeof(struct _ssPortOutputs));

10937
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

10938
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

10939
          _ssSetNumOutputPorts(childS, 1);

10940


10941
          /* port 0 */

10942
          {

10943
            _ssSetOutputPortNumDimensions(childS, 0, 1);

10944
            ssSetOutputPortWidth(childS, 0, 1);

10945
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

10946
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_e));

10947
          }

10948
        }

10949


10950
        /* path info */

10951
        _ssSetModelName(childS, "SaturationLimiter_sf");

10952
        _ssSetPath(childS,

10953
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Saturation Limiter2/Generated S-Function1");

10954
        if (ssGetRTModel(rts) == (NULL)) {

10955
          _ssSetParentSS(childS, rts);

10956
          _ssSetRootSS(childS, ssGetRootSS(rts));

10957
        } else {

10958
          ssSetRTModel(childS,ssGetRTModel(rts));

10959
          _ssSetParentSS(childS, (NULL));

10960
          _ssSetRootSS(childS, childS);

10961
        }

10962


10963
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

10964
        (childS)->regDataType.arg1 = ((void *)(childS));

10965
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

10966
          FcnSetErrorStatus);

10967
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

10968
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

10969
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

10970
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

10971


10972
        /* registration */

10973
#if defined(MATLAB_MEX_FILE)

10974


10975
        {

10976
          int_T i;

10977
          mxArray *plhs[1];

10978
          mxArray *prhs[4];

10979
          double *pr;

10980
          volatile int_T *intS = (int_T *)&childS;

10981
          int_T addrlen = sizeof(SimStruct *);

10982
          int_T m = addrlen/sizeof(int_T) + 1;

10983
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

10984
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

10985
          pr = mxGetPr(prhs[1]);

10986
          for (i = 0; i < m - 1; i++) {

10987
            pr[i] = (double)intS[i];

10988
          }

10989


10990
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

10991
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

10992
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

10993


10994
          /* Reset port dimensions info functions because the S-function

10995
           * and accelerator mex-files explicitly set their dimensions,

10996
           * i.e., they are not dynamically sized. For this case, the

10997
           * mex-file is responsible for the dimensions info memory

10998
           * and Simulink should not free it. This is achieved by

10999
           * setting the following two methods to NULL.

11000
           */

11001
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

11002
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

11003


11004
          /*

11005
           * Setup function pointers and call mdlInitializeSizes via

11006
           * simulink.c

11007
           */

11008
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

11009
          mxDestroyArray(plhs[0]);

11010
          mxDestroyArray(prhs[0]);

11011
          mxDestroyArray(prhs[1]);

11012
          mxDestroyArray(prhs[2]);

11013
          mxDestroyArray(prhs[3]);

11014
        }

11015


11016
#else

11017


11018
        {

11019
          SaturationLimiter_sf(childS);

11020
          sfcnInitializeSizes(childS);

11021
        }

11022


11023
#endif

11024


11025
        sfcnInitializeSampleTimes(childS);

11026


11027
        /* adjust sample time */

11028
        ssSetSampleTime(childS, 0, 0.0);

11029
        ssSetOffsetTime(childS, 0, 0.0);

11030
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

11031


11032
        /* set compiled values of dynamic vector attributes */

11033
        ssSetNumNonsampledZCs(childS, 0);

11034


11035
        /* Update connectivity flags for each port */

11036
        _ssSetInputPortConnected(childS, 0, 1);

11037
        _ssSetInputPortConnected(childS, 1, 1);

11038
        _ssSetInputPortConnected(childS, 2, 1);

11039
        _ssSetOutputPortConnected(childS, 0, 1);

11040
        _ssSetOutputPortBeingMerged(childS, 0, 0);

11041


11042
        /* Update the BufferDstPort flags for each input port */

11043
        _ssSetInputPortBufferDstPort(childS, 0, -1);

11044
        _ssSetInputPortBufferDstPort(childS, 1, -1);

11045
        _ssSetInputPortBufferDstPort(childS, 2, -1);

11046
      }

11047


11048
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S98>/Generated S-Function4 (LagFilter_sf) */

11049
      {

11050
        SimStruct *childS = ssGetSFunction(rts, 41);

11051


11052
        /* timing info */

11053
        time_T *sfcnPeriod;

11054
        time_T *sfcnOffset;

11055
        int_T *sfcnTsMap;

11056
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

11057
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

11058
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

11059
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

11060
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

11061
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

11062
        (void) memset((void*)sfcnPeriod, 0,

11063
                      sizeof(time_T)*1);

11064
        (void) memset((void*)sfcnOffset, 0,

11065
                      sizeof(time_T)*1);

11066
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

11067
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

11068
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

11069


11070
        /* Set up the mdlInfo pointer */

11071
# ifdef USE_RTMODEL

11072


11073
        {

11074
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

11075
              struct _ssBlkInfo2));

11076
          ss_VALIDATE_MEMORY(rts,blkInfo2);

11077
          ssSetBlkInfo2Ptr(childS, blkInfo2);

11078
        }

11079


11080
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

11081


11082
# else

11083


11084
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

11085


11086
# endif                                /* USE_RTMODEL */

11087


11088
        /* Allocate memory of model methods 2 */

11089
        {

11090
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

11091
            malloc(sizeof(struct _ssSFcnModelMethods2));

11092
          ss_VALIDATE_MEMORY(rts,methods2);

11093
          ssSetModelMethods2(childS, methods2);

11094
        }

11095


11096
        /* Allocate memory of model methods 3 */

11097
        {

11098
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

11099
            malloc(sizeof(struct _ssSFcnModelMethods3));

11100
          ss_VALIDATE_MEMORY(rts,methods3);

11101
          ssSetModelMethods3(childS, methods3);

11102
        }

11103


11104
        /* Allocate memory for states auxilliary information */

11105
        {

11106
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

11107
            (sizeof(struct _ssStatesInfo2));

11108
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

11109
            malloc(sizeof(ssPeriodicStatesInfo));

11110
          ss_VALIDATE_MEMORY(rts,statesInfo2);

11111
          ssSetStatesInfo2(childS, statesInfo2);

11112
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

11113
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

11114
        }

11115


11116
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

11117
          RegNumInputPorts);

11118
        ssSetRegNumInputPortsFcnArg(childS,childS);

11119


11120
        /* inputs */

11121
        {

11122
          struct _ssPortInputs *inputPortInfo =

11123
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

11124
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

11125
          _ssSetNumInputPorts(childS, 6);

11126
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

11127


11128
          /* port 0 */

11129
          {

11130
            real32_T const **sfcnUPtrs = (real32_T const **)

11131
              malloc(1 * sizeof(real32_T *));

11132
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11133
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

11134
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

11135
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

11136
            _ssSetInputPortNumDimensions(childS, 0, 1);

11137
            ssSetInputPortWidth(childS, 0, 1);

11138
          }

11139


11140
          /* port 1 */

11141
          {

11142
            int8_T const **sfcnUPtrs = (int8_T const **)

11143
              malloc(1 * sizeof(int8_T *));

11144
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11145
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

11146
              ssGetLocalBlockIO(rts))->DataTypeConversion2_c;

11147
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

11148
            _ssSetInputPortNumDimensions(childS, 1, 1);

11149
            ssSetInputPortWidth(childS, 1, 1);

11150
          }

11151


11152
          /* port 2 */

11153
          {

11154
            real32_T const **sfcnUPtrs = (real32_T const **)

11155
              malloc(1 * sizeof(real32_T *));

11156
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11157
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

11158
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

11159
            _ssSetInputPortNumDimensions(childS, 2, 1);

11160
            ssSetInputPortWidth(childS, 2, 1);

11161
          }

11162


11163
          /* port 3 */

11164
          {

11165
            real32_T const **sfcnUPtrs = (real32_T const **)

11166
              malloc(1 * sizeof(real32_T *));

11167
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11168
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

11169
              ssGetLocalBlockIO(rts))->Switch_aj;

11170
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

11171
            _ssSetInputPortNumDimensions(childS, 3, 1);

11172
            ssSetInputPortWidth(childS, 3, 1);

11173
          }

11174


11175
          /* port 4 */

11176
          {

11177
            real32_T const **sfcnUPtrs = (real32_T const **)

11178
              malloc(1 * sizeof(real32_T *));

11179
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11180
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

11181
              ssGetLocalBlockIO(rts))->Switch_aj;

11182
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

11183
            _ssSetInputPortNumDimensions(childS, 4, 1);

11184
            ssSetInputPortWidth(childS, 4, 1);

11185
          }

11186


11187
          /* port 5 */

11188
          {

11189
            real32_T const **sfcnUPtrs = (real32_T const **)

11190
              malloc(1 * sizeof(real32_T *));

11191
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11192
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

11193
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_e;

11194
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

11195
            _ssSetInputPortNumDimensions(childS, 5, 1);

11196
            ssSetInputPortWidth(childS, 5, 1);

11197
          }

11198
        }

11199


11200
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

11201
          RegNumOutputPorts);

11202
        ssSetRegNumOutputPortsFcnArg(childS,childS);

11203


11204
        /* outputs */

11205
        {

11206
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

11207
            calloc(1, sizeof(struct _ssPortOutputs));

11208
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

11209
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

11210
          _ssSetNumOutputPorts(childS, 1);

11211


11212
          /* port 0 */

11213
          {

11214
            _ssSetOutputPortNumDimensions(childS, 0, 1);

11215
            ssSetOutputPortWidth(childS, 0, 1);

11216
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

11217
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_c));

11218
          }

11219
        }

11220


11221
        /* path info */

11222
        _ssSetModelName(childS, "LagFilter_sf");

11223
        _ssSetPath(childS,

11224
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/ lag filter/Generated S-Function4");

11225
        if (ssGetRTModel(rts) == (NULL)) {

11226
          _ssSetParentSS(childS, rts);

11227
          _ssSetRootSS(childS, ssGetRootSS(rts));

11228
        } else {

11229
          ssSetRTModel(childS,ssGetRTModel(rts));

11230
          _ssSetParentSS(childS, (NULL));

11231
          _ssSetRootSS(childS, childS);

11232
        }

11233


11234
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

11235


11236
        /* work vectors */

11237
        {

11238
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

11239
            (4 * sizeof(struct _ssDWorkRecord));

11240
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

11241
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

11242
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

11243
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

11244
          ssSetSFcnDWork(childS, dWorkRecord);

11245
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

11246
          _ssSetNumDWork(childS, 4);

11247


11248
          /* DWORK0 */

11249
          ssSetDWorkWidth(childS, 0, 1);

11250
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

11251
          ssSetDWorkComplexSignal(childS, 0, 0);

11252
          ssSetDWorkUsedAsDState(childS, 0, 1);

11253
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 180))[0]);

11254


11255
          /* DWORK1 */

11256
          ssSetDWorkWidth(childS, 1, 1);

11257
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

11258
          ssSetDWorkComplexSignal(childS, 1, 0);

11259
          ssSetDWorkUsedAsDState(childS, 1, 1);

11260
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 181))[0]);

11261


11262
          /* DWORK2 */

11263
          ssSetDWorkWidth(childS, 2, 1);

11264
          ssSetDWorkDataType(childS, 2,SS_INT8);

11265
          ssSetDWorkComplexSignal(childS, 2, 0);

11266
          ssSetDWorkUsedAsDState(childS, 2, 1);

11267
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 407))[0]);

11268


11269
          /* DWORK3 */

11270
          ssSetDWorkWidth(childS, 3, 1);

11271
          ssSetDWorkDataType(childS, 3,SS_INT8);

11272
          ssSetDWorkComplexSignal(childS, 3, 0);

11273
          ssSetDWorkUsedAsDState(childS, 3, 1);

11274
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 408))[0]);

11275
        }

11276


11277
        (childS)->regDataType.arg1 = ((void *)(childS));

11278
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

11279
          FcnSetErrorStatus);

11280
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

11281
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

11282
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

11283
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

11284


11285
        /* registration */

11286
#if defined(MATLAB_MEX_FILE)

11287


11288
        {

11289
          int_T i;

11290
          mxArray *plhs[1];

11291
          mxArray *prhs[4];

11292
          double *pr;

11293
          volatile int_T *intS = (int_T *)&childS;

11294
          int_T addrlen = sizeof(SimStruct *);

11295
          int_T m = addrlen/sizeof(int_T) + 1;

11296
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

11297
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

11298
          pr = mxGetPr(prhs[1]);

11299
          for (i = 0; i < m - 1; i++) {

11300
            pr[i] = (double)intS[i];

11301
          }

11302


11303
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

11304
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

11305
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

11306


11307
          /* Reset port dimensions info functions because the S-function

11308
           * and accelerator mex-files explicitly set their dimensions,

11309
           * i.e., they are not dynamically sized. For this case, the

11310
           * mex-file is responsible for the dimensions info memory

11311
           * and Simulink should not free it. This is achieved by

11312
           * setting the following two methods to NULL.

11313
           */

11314
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

11315
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

11316


11317
          /*

11318
           * Setup function pointers and call mdlInitializeSizes via

11319
           * simulink.c

11320
           */

11321
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

11322
          mxDestroyArray(plhs[0]);

11323
          mxDestroyArray(prhs[0]);

11324
          mxDestroyArray(prhs[1]);

11325
          mxDestroyArray(prhs[2]);

11326
          mxDestroyArray(prhs[3]);

11327
        }

11328


11329
#else

11330


11331
        {

11332
          LagFilter_sf(childS);

11333
          sfcnInitializeSizes(childS);

11334
        }

11335


11336
#endif

11337


11338
        sfcnInitializeSampleTimes(childS);

11339


11340
        /* adjust sample time */

11341
        ssSetSampleTime(childS, 0, 0.0);

11342
        ssSetOffsetTime(childS, 0, 0.0);

11343
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

11344


11345
        /* set compiled values of dynamic vector attributes */

11346
        ssSetNumNonsampledZCs(childS, 0);

11347


11348
        /* Update connectivity flags for each port */

11349
        _ssSetInputPortConnected(childS, 0, 1);

11350
        _ssSetInputPortConnected(childS, 1, 1);

11351
        _ssSetInputPortConnected(childS, 2, 1);

11352
        _ssSetInputPortConnected(childS, 3, 1);

11353
        _ssSetInputPortConnected(childS, 4, 1);

11354
        _ssSetInputPortConnected(childS, 5, 1);

11355
        _ssSetOutputPortConnected(childS, 0, 1);

11356
        _ssSetOutputPortBeingMerged(childS, 0, 0);

11357


11358
        /* Update the BufferDstPort flags for each input port */

11359
        _ssSetInputPortBufferDstPort(childS, 0, -1);

11360
        _ssSetInputPortBufferDstPort(childS, 1, -1);

11361
        _ssSetInputPortBufferDstPort(childS, 2, -1);

11362
        _ssSetInputPortBufferDstPort(childS, 3, -1);

11363
        _ssSetInputPortBufferDstPort(childS, 4, -1);

11364
        _ssSetInputPortBufferDstPort(childS, 5, -1);

11365
      }

11366


11367
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S109>/Generated S-Function1 (SaturationLimiter_sf) */

11368
      {

11369
        SimStruct *childS = ssGetSFunction(rts, 42);

11370


11371
        /* timing info */

11372
        time_T *sfcnPeriod;

11373
        time_T *sfcnOffset;

11374
        int_T *sfcnTsMap;

11375
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

11376
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

11377
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

11378
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

11379
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

11380
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

11381
        (void) memset((void*)sfcnPeriod, 0,

11382
                      sizeof(time_T)*1);

11383
        (void) memset((void*)sfcnOffset, 0,

11384
                      sizeof(time_T)*1);

11385
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

11386
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

11387
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

11388


11389
        /* Set up the mdlInfo pointer */

11390
# ifdef USE_RTMODEL

11391


11392
        {

11393
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

11394
              struct _ssBlkInfo2));

11395
          ss_VALIDATE_MEMORY(rts,blkInfo2);

11396
          ssSetBlkInfo2Ptr(childS, blkInfo2);

11397
        }

11398


11399
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

11400


11401
# else

11402


11403
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

11404


11405
# endif                                /* USE_RTMODEL */

11406


11407
        /* Allocate memory of model methods 2 */

11408
        {

11409
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

11410
            malloc(sizeof(struct _ssSFcnModelMethods2));

11411
          ss_VALIDATE_MEMORY(rts,methods2);

11412
          ssSetModelMethods2(childS, methods2);

11413
        }

11414


11415
        /* Allocate memory of model methods 3 */

11416
        {

11417
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

11418
            malloc(sizeof(struct _ssSFcnModelMethods3));

11419
          ss_VALIDATE_MEMORY(rts,methods3);

11420
          ssSetModelMethods3(childS, methods3);

11421
        }

11422


11423
        /* Allocate memory for states auxilliary information */

11424
        {

11425
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

11426
            (sizeof(struct _ssStatesInfo2));

11427
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

11428
            malloc(sizeof(ssPeriodicStatesInfo));

11429
          ss_VALIDATE_MEMORY(rts,statesInfo2);

11430
          ssSetStatesInfo2(childS, statesInfo2);

11431
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

11432
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

11433
        }

11434


11435
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

11436
          RegNumInputPorts);

11437
        ssSetRegNumInputPortsFcnArg(childS,childS);

11438


11439
        /* inputs */

11440
        {

11441
          struct _ssPortInputs *inputPortInfo =

11442
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

11443
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

11444
          _ssSetNumInputPorts(childS, 3);

11445
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

11446


11447
          /* port 0 */

11448
          {

11449
            real32_T const **sfcnUPtrs = (real32_T const **)

11450
              malloc(1 * sizeof(real32_T *));

11451
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11452
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

11453
              ssGetLocalBlockIO(rts))->Sum1_i;

11454
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

11455
            _ssSetInputPortNumDimensions(childS, 0, 1);

11456
            ssSetInputPortWidth(childS, 0, 1);

11457
          }

11458


11459
          /* port 1 */

11460
          {

11461
            real32_T const **sfcnUPtrs = (real32_T const **)

11462
              malloc(1 * sizeof(real32_T *));

11463
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11464
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

11465
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

11466
            _ssSetInputPortNumDimensions(childS, 1, 1);

11467
            ssSetInputPortWidth(childS, 1, 1);

11468
          }

11469


11470
          /* port 2 */

11471
          {

11472
            real32_T const **sfcnUPtrs = (real32_T const **)

11473
              malloc(1 * sizeof(real32_T *));

11474
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11475
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

11476
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

11477
            _ssSetInputPortNumDimensions(childS, 2, 1);

11478
            ssSetInputPortWidth(childS, 2, 1);

11479
          }

11480
        }

11481


11482
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

11483
          RegNumOutputPorts);

11484
        ssSetRegNumOutputPortsFcnArg(childS,childS);

11485


11486
        /* outputs */

11487
        {

11488
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

11489
            calloc(1, sizeof(struct _ssPortOutputs));

11490
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

11491
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

11492
          _ssSetNumOutputPorts(childS, 1);

11493


11494
          /* port 0 */

11495
          {

11496
            _ssSetOutputPortNumDimensions(childS, 0, 1);

11497
            ssSetOutputPortWidth(childS, 0, 1);

11498
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

11499
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_g));

11500
          }

11501
        }

11502


11503
        /* path info */

11504
        _ssSetModelName(childS, "SaturationLimiter_sf");

11505
        _ssSetPath(childS,

11506
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Saturation Limiter1/Generated S-Function1");

11507
        if (ssGetRTModel(rts) == (NULL)) {

11508
          _ssSetParentSS(childS, rts);

11509
          _ssSetRootSS(childS, ssGetRootSS(rts));

11510
        } else {

11511
          ssSetRTModel(childS,ssGetRTModel(rts));

11512
          _ssSetParentSS(childS, (NULL));

11513
          _ssSetRootSS(childS, childS);

11514
        }

11515


11516
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

11517
        (childS)->regDataType.arg1 = ((void *)(childS));

11518
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

11519
          FcnSetErrorStatus);

11520
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

11521
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

11522
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

11523
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

11524


11525
        /* registration */

11526
#if defined(MATLAB_MEX_FILE)

11527


11528
        {

11529
          int_T i;

11530
          mxArray *plhs[1];

11531
          mxArray *prhs[4];

11532
          double *pr;

11533
          volatile int_T *intS = (int_T *)&childS;

11534
          int_T addrlen = sizeof(SimStruct *);

11535
          int_T m = addrlen/sizeof(int_T) + 1;

11536
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

11537
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

11538
          pr = mxGetPr(prhs[1]);

11539
          for (i = 0; i < m - 1; i++) {

11540
            pr[i] = (double)intS[i];

11541
          }

11542


11543
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

11544
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

11545
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

11546


11547
          /* Reset port dimensions info functions because the S-function

11548
           * and accelerator mex-files explicitly set their dimensions,

11549
           * i.e., they are not dynamically sized. For this case, the

11550
           * mex-file is responsible for the dimensions info memory

11551
           * and Simulink should not free it. This is achieved by

11552
           * setting the following two methods to NULL.

11553
           */

11554
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

11555
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

11556


11557
          /*

11558
           * Setup function pointers and call mdlInitializeSizes via

11559
           * simulink.c

11560
           */

11561
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

11562
          mxDestroyArray(plhs[0]);

11563
          mxDestroyArray(prhs[0]);

11564
          mxDestroyArray(prhs[1]);

11565
          mxDestroyArray(prhs[2]);

11566
          mxDestroyArray(prhs[3]);

11567
        }

11568


11569
#else

11570


11571
        {

11572
          SaturationLimiter_sf(childS);

11573
          sfcnInitializeSizes(childS);

11574
        }

11575


11576
#endif

11577


11578
        sfcnInitializeSampleTimes(childS);

11579


11580
        /* adjust sample time */

11581
        ssSetSampleTime(childS, 0, 0.0);

11582
        ssSetOffsetTime(childS, 0, 0.0);

11583
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

11584


11585
        /* set compiled values of dynamic vector attributes */

11586
        ssSetNumNonsampledZCs(childS, 0);

11587


11588
        /* Update connectivity flags for each port */

11589
        _ssSetInputPortConnected(childS, 0, 1);

11590
        _ssSetInputPortConnected(childS, 1, 1);

11591
        _ssSetInputPortConnected(childS, 2, 1);

11592
        _ssSetOutputPortConnected(childS, 0, 1);

11593
        _ssSetOutputPortBeingMerged(childS, 0, 0);

11594


11595
        /* Update the BufferDstPort flags for each input port */

11596
        _ssSetInputPortBufferDstPort(childS, 0, -1);

11597
        _ssSetInputPortBufferDstPort(childS, 1, -1);

11598
        _ssSetInputPortBufferDstPort(childS, 2, -1);

11599
      }

11600


11601
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S111>/Generated S-Function (Gain_sf) */

11602
      {

11603
        SimStruct *childS = ssGetSFunction(rts, 43);

11604


11605
        /* timing info */

11606
        time_T *sfcnPeriod;

11607
        time_T *sfcnOffset;

11608
        int_T *sfcnTsMap;

11609
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

11610
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

11611
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

11612
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

11613
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

11614
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

11615
        (void) memset((void*)sfcnPeriod, 0,

11616
                      sizeof(time_T)*1);

11617
        (void) memset((void*)sfcnOffset, 0,

11618
                      sizeof(time_T)*1);

11619
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

11620
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

11621
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

11622


11623
        /* Set up the mdlInfo pointer */

11624
# ifdef USE_RTMODEL

11625


11626
        {

11627
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

11628
              struct _ssBlkInfo2));

11629
          ss_VALIDATE_MEMORY(rts,blkInfo2);

11630
          ssSetBlkInfo2Ptr(childS, blkInfo2);

11631
        }

11632


11633
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

11634


11635
# else

11636


11637
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

11638


11639
# endif                                /* USE_RTMODEL */

11640


11641
        /* Allocate memory of model methods 2 */

11642
        {

11643
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

11644
            malloc(sizeof(struct _ssSFcnModelMethods2));

11645
          ss_VALIDATE_MEMORY(rts,methods2);

11646
          ssSetModelMethods2(childS, methods2);

11647
        }

11648


11649
        /* Allocate memory of model methods 3 */

11650
        {

11651
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

11652
            malloc(sizeof(struct _ssSFcnModelMethods3));

11653
          ss_VALIDATE_MEMORY(rts,methods3);

11654
          ssSetModelMethods3(childS, methods3);

11655
        }

11656


11657
        /* Allocate memory for states auxilliary information */

11658
        {

11659
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

11660
            (sizeof(struct _ssStatesInfo2));

11661
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

11662
            malloc(sizeof(ssPeriodicStatesInfo));

11663
          ss_VALIDATE_MEMORY(rts,statesInfo2);

11664
          ssSetStatesInfo2(childS, statesInfo2);

11665
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

11666
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

11667
        }

11668


11669
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

11670
          RegNumInputPorts);

11671
        ssSetRegNumInputPortsFcnArg(childS,childS);

11672


11673
        /* inputs */

11674
        {

11675
          struct _ssPortInputs *inputPortInfo =

11676
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

11677
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

11678
          _ssSetNumInputPorts(childS, 2);

11679
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

11680


11681
          /* port 0 */

11682
          {

11683
            real32_T const **sfcnUPtrs = (real32_T const **)

11684
              malloc(1 * sizeof(real32_T *));

11685
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11686
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

11687
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_g;

11688
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

11689
            _ssSetInputPortNumDimensions(childS, 0, 1);

11690
            ssSetInputPortWidth(childS, 0, 1);

11691
          }

11692


11693
          /* port 1 */

11694
          {

11695
            real32_T const **sfcnUPtrs = (real32_T const **)

11696
              malloc(1 * sizeof(real32_T *));

11697
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11698
            sfcnUPtrs[0] = (real32_T const *)

11699
              &AFCS_MODEL1_ConstP.Constant13_Value_n;

11700
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

11701
            _ssSetInputPortNumDimensions(childS, 1, 1);

11702
            ssSetInputPortWidth(childS, 1, 1);

11703
          }

11704
        }

11705


11706
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

11707
          RegNumOutputPorts);

11708
        ssSetRegNumOutputPortsFcnArg(childS,childS);

11709


11710
        /* outputs */

11711
        {

11712
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

11713
            calloc(1, sizeof(struct _ssPortOutputs));

11714
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

11715
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

11716
          _ssSetNumOutputPorts(childS, 1);

11717


11718
          /* port 0 */

11719
          {

11720
            _ssSetOutputPortNumDimensions(childS, 0, 1);

11721
            ssSetOutputPortWidth(childS, 0, 1);

11722
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

11723
              ssGetLocalBlockIO(rts))->GeneratedSFunction_nx));

11724
          }

11725
        }

11726


11727
        /* path info */

11728
        _ssSetModelName(childS, "Gain_sf");

11729
        _ssSetPath(childS,

11730
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/gain/Generated S-Function");

11731
        if (ssGetRTModel(rts) == (NULL)) {

11732
          _ssSetParentSS(childS, rts);

11733
          _ssSetRootSS(childS, ssGetRootSS(rts));

11734
        } else {

11735
          ssSetRTModel(childS,ssGetRTModel(rts));

11736
          _ssSetParentSS(childS, (NULL));

11737
          _ssSetRootSS(childS, childS);

11738
        }

11739


11740
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

11741
        (childS)->regDataType.arg1 = ((void *)(childS));

11742
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

11743
          FcnSetErrorStatus);

11744
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

11745
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

11746
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

11747
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

11748


11749
        /* registration */

11750
#if defined(MATLAB_MEX_FILE)

11751


11752
        {

11753
          int_T i;

11754
          mxArray *plhs[1];

11755
          mxArray *prhs[4];

11756
          double *pr;

11757
          volatile int_T *intS = (int_T *)&childS;

11758
          int_T addrlen = sizeof(SimStruct *);

11759
          int_T m = addrlen/sizeof(int_T) + 1;

11760
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

11761
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

11762
          pr = mxGetPr(prhs[1]);

11763
          for (i = 0; i < m - 1; i++) {

11764
            pr[i] = (double)intS[i];

11765
          }

11766


11767
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

11768
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

11769
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

11770


11771
          /* Reset port dimensions info functions because the S-function

11772
           * and accelerator mex-files explicitly set their dimensions,

11773
           * i.e., they are not dynamically sized. For this case, the

11774
           * mex-file is responsible for the dimensions info memory

11775
           * and Simulink should not free it. This is achieved by

11776
           * setting the following two methods to NULL.

11777
           */

11778
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

11779
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

11780


11781
          /*

11782
           * Setup function pointers and call mdlInitializeSizes via

11783
           * simulink.c

11784
           */

11785
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

11786
          mxDestroyArray(plhs[0]);

11787
          mxDestroyArray(prhs[0]);

11788
          mxDestroyArray(prhs[1]);

11789
          mxDestroyArray(prhs[2]);

11790
          mxDestroyArray(prhs[3]);

11791
        }

11792


11793
#else

11794


11795
        {

11796
          Gain_sf(childS);

11797
          sfcnInitializeSizes(childS);

11798
        }

11799


11800
#endif

11801


11802
        sfcnInitializeSampleTimes(childS);

11803


11804
        /* adjust sample time */

11805
        ssSetSampleTime(childS, 0, 0.0);

11806
        ssSetOffsetTime(childS, 0, 0.0);

11807
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

11808


11809
        /* set compiled values of dynamic vector attributes */

11810
        ssSetNumNonsampledZCs(childS, 0);

11811


11812
        /* Update connectivity flags for each port */

11813
        _ssSetInputPortConnected(childS, 0, 1);

11814
        _ssSetInputPortConnected(childS, 1, 1);

11815
        _ssSetOutputPortConnected(childS, 0, 1);

11816
        _ssSetOutputPortBeingMerged(childS, 0, 0);

11817


11818
        /* Update the BufferDstPort flags for each input port */

11819
        _ssSetInputPortBufferDstPort(childS, 0, -1);

11820
        _ssSetInputPortBufferDstPort(childS, 1, -1);

11821
      }

11822


11823
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S112>/Generated S-Function (Gain_sf) */

11824
      {

11825
        SimStruct *childS = ssGetSFunction(rts, 44);

11826


11827
        /* timing info */

11828
        time_T *sfcnPeriod;

11829
        time_T *sfcnOffset;

11830
        int_T *sfcnTsMap;

11831
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

11832
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

11833
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

11834
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

11835
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

11836
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

11837
        (void) memset((void*)sfcnPeriod, 0,

11838
                      sizeof(time_T)*1);

11839
        (void) memset((void*)sfcnOffset, 0,

11840
                      sizeof(time_T)*1);

11841
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

11842
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

11843
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

11844


11845
        /* Set up the mdlInfo pointer */

11846
# ifdef USE_RTMODEL

11847


11848
        {

11849
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

11850
              struct _ssBlkInfo2));

11851
          ss_VALIDATE_MEMORY(rts,blkInfo2);

11852
          ssSetBlkInfo2Ptr(childS, blkInfo2);

11853
        }

11854


11855
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

11856


11857
# else

11858


11859
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

11860


11861
# endif                                /* USE_RTMODEL */

11862


11863
        /* Allocate memory of model methods 2 */

11864
        {

11865
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

11866
            malloc(sizeof(struct _ssSFcnModelMethods2));

11867
          ss_VALIDATE_MEMORY(rts,methods2);

11868
          ssSetModelMethods2(childS, methods2);

11869
        }

11870


11871
        /* Allocate memory of model methods 3 */

11872
        {

11873
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

11874
            malloc(sizeof(struct _ssSFcnModelMethods3));

11875
          ss_VALIDATE_MEMORY(rts,methods3);

11876
          ssSetModelMethods3(childS, methods3);

11877
        }

11878


11879
        /* Allocate memory for states auxilliary information */

11880
        {

11881
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

11882
            (sizeof(struct _ssStatesInfo2));

11883
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

11884
            malloc(sizeof(ssPeriodicStatesInfo));

11885
          ss_VALIDATE_MEMORY(rts,statesInfo2);

11886
          ssSetStatesInfo2(childS, statesInfo2);

11887
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

11888
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

11889
        }

11890


11891
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

11892
          RegNumInputPorts);

11893
        ssSetRegNumInputPortsFcnArg(childS,childS);

11894


11895
        /* inputs */

11896
        {

11897
          struct _ssPortInputs *inputPortInfo =

11898
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

11899
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

11900
          _ssSetNumInputPorts(childS, 2);

11901
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

11902


11903
          /* port 0 */

11904
          {

11905
            real32_T const **sfcnUPtrs = (real32_T const **)

11906
              malloc(1 * sizeof(real32_T *));

11907
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11908
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

11909
              ssGetLocalBlockIO(rts))->GeneratedSFunction_nx;

11910
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

11911
            _ssSetInputPortNumDimensions(childS, 0, 1);

11912
            ssSetInputPortWidth(childS, 0, 1);

11913
          }

11914


11915
          /* port 1 */

11916
          {

11917
            real32_T const **sfcnUPtrs = (real32_T const **)

11918
              malloc(1 * sizeof(real32_T *));

11919
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

11920
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

11921
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

11922
            _ssSetInputPortNumDimensions(childS, 1, 1);

11923
            ssSetInputPortWidth(childS, 1, 1);

11924
          }

11925
        }

11926


11927
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

11928
          RegNumOutputPorts);

11929
        ssSetRegNumOutputPortsFcnArg(childS,childS);

11930


11931
        /* outputs */

11932
        {

11933
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

11934
            calloc(1, sizeof(struct _ssPortOutputs));

11935
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

11936
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

11937
          _ssSetNumOutputPorts(childS, 1);

11938


11939
          /* port 0 */

11940
          {

11941
            _ssSetOutputPortNumDimensions(childS, 0, 1);

11942
            ssSetOutputPortWidth(childS, 0, 1);

11943
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

11944
              ssGetLocalBlockIO(rts))->GeneratedSFunction_d));

11945
          }

11946
        }

11947


11948
        /* path info */

11949
        _ssSetModelName(childS, "Gain_sf");

11950
        _ssSetPath(childS,

11951
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/gain4/Generated S-Function");

11952
        if (ssGetRTModel(rts) == (NULL)) {

11953
          _ssSetParentSS(childS, rts);

11954
          _ssSetRootSS(childS, ssGetRootSS(rts));

11955
        } else {

11956
          ssSetRTModel(childS,ssGetRTModel(rts));

11957
          _ssSetParentSS(childS, (NULL));

11958
          _ssSetRootSS(childS, childS);

11959
        }

11960


11961
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

11962
        (childS)->regDataType.arg1 = ((void *)(childS));

11963
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

11964
          FcnSetErrorStatus);

11965
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

11966
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

11967
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

11968
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

11969


11970
        /* registration */

11971
#if defined(MATLAB_MEX_FILE)

11972


11973
        {

11974
          int_T i;

11975
          mxArray *plhs[1];

11976
          mxArray *prhs[4];

11977
          double *pr;

11978
          volatile int_T *intS = (int_T *)&childS;

11979
          int_T addrlen = sizeof(SimStruct *);

11980
          int_T m = addrlen/sizeof(int_T) + 1;

11981
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

11982
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

11983
          pr = mxGetPr(prhs[1]);

11984
          for (i = 0; i < m - 1; i++) {

11985
            pr[i] = (double)intS[i];

11986
          }

11987


11988
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

11989
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

11990
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

11991


11992
          /* Reset port dimensions info functions because the S-function

11993
           * and accelerator mex-files explicitly set their dimensions,

11994
           * i.e., they are not dynamically sized. For this case, the

11995
           * mex-file is responsible for the dimensions info memory

11996
           * and Simulink should not free it. This is achieved by

11997
           * setting the following two methods to NULL.

11998
           */

11999
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

12000
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

12001


12002
          /*

12003
           * Setup function pointers and call mdlInitializeSizes via

12004
           * simulink.c

12005
           */

12006
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

12007
          mxDestroyArray(plhs[0]);

12008
          mxDestroyArray(prhs[0]);

12009
          mxDestroyArray(prhs[1]);

12010
          mxDestroyArray(prhs[2]);

12011
          mxDestroyArray(prhs[3]);

12012
        }

12013


12014
#else

12015


12016
        {

12017
          Gain_sf(childS);

12018
          sfcnInitializeSizes(childS);

12019
        }

12020


12021
#endif

12022


12023
        sfcnInitializeSampleTimes(childS);

12024


12025
        /* adjust sample time */

12026
        ssSetSampleTime(childS, 0, 0.0);

12027
        ssSetOffsetTime(childS, 0, 0.0);

12028
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

12029


12030
        /* set compiled values of dynamic vector attributes */

12031
        ssSetNumNonsampledZCs(childS, 0);

12032


12033
        /* Update connectivity flags for each port */

12034
        _ssSetInputPortConnected(childS, 0, 1);

12035
        _ssSetInputPortConnected(childS, 1, 1);

12036
        _ssSetOutputPortConnected(childS, 0, 1);

12037
        _ssSetOutputPortBeingMerged(childS, 0, 0);

12038


12039
        /* Update the BufferDstPort flags for each input port */

12040
        _ssSetInputPortBufferDstPort(childS, 0, -1);

12041
        _ssSetInputPortBufferDstPort(childS, 1, -1);

12042
      }

12043


12044
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S107>/Generated S-Function3 (IntegratorLimited_sf) */

12045
      {

12046
        SimStruct *childS = ssGetSFunction(rts, 45);

12047


12048
        /* timing info */

12049
        time_T *sfcnPeriod;

12050
        time_T *sfcnOffset;

12051
        int_T *sfcnTsMap;

12052
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

12053
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

12054
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

12055
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

12056
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

12057
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

12058
        (void) memset((void*)sfcnPeriod, 0,

12059
                      sizeof(time_T)*1);

12060
        (void) memset((void*)sfcnOffset, 0,

12061
                      sizeof(time_T)*1);

12062
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

12063
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

12064
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

12065


12066
        /* Set up the mdlInfo pointer */

12067
# ifdef USE_RTMODEL

12068


12069
        {

12070
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

12071
              struct _ssBlkInfo2));

12072
          ss_VALIDATE_MEMORY(rts,blkInfo2);

12073
          ssSetBlkInfo2Ptr(childS, blkInfo2);

12074
        }

12075


12076
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

12077


12078
# else

12079


12080
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

12081


12082
# endif                                /* USE_RTMODEL */

12083


12084
        /* Allocate memory of model methods 2 */

12085
        {

12086
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

12087
            malloc(sizeof(struct _ssSFcnModelMethods2));

12088
          ss_VALIDATE_MEMORY(rts,methods2);

12089
          ssSetModelMethods2(childS, methods2);

12090
        }

12091


12092
        /* Allocate memory of model methods 3 */

12093
        {

12094
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

12095
            malloc(sizeof(struct _ssSFcnModelMethods3));

12096
          ss_VALIDATE_MEMORY(rts,methods3);

12097
          ssSetModelMethods3(childS, methods3);

12098
        }

12099


12100
        /* Allocate memory for states auxilliary information */

12101
        {

12102
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

12103
            (sizeof(struct _ssStatesInfo2));

12104
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

12105
            malloc(sizeof(ssPeriodicStatesInfo));

12106
          ss_VALIDATE_MEMORY(rts,statesInfo2);

12107
          ssSetStatesInfo2(childS, statesInfo2);

12108
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

12109
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

12110
        }

12111


12112
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

12113
          RegNumInputPorts);

12114
        ssSetRegNumInputPortsFcnArg(childS,childS);

12115


12116
        /* inputs */

12117
        {

12118
          struct _ssPortInputs *inputPortInfo =

12119
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

12120
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

12121
          _ssSetNumInputPorts(childS, 7);

12122
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

12123


12124
          /* port 0 */

12125
          {

12126
            real32_T const **sfcnUPtrs = (real32_T const **)

12127
              malloc(1 * sizeof(real32_T *));

12128
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12129
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12130
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

12131
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

12132
            _ssSetInputPortNumDimensions(childS, 0, 1);

12133
            ssSetInputPortWidth(childS, 0, 1);

12134
          }

12135


12136
          /* port 1 */

12137
          {

12138
            int8_T const **sfcnUPtrs = (int8_T const **)

12139
              malloc(1 * sizeof(int8_T *));

12140
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12141
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

12142
              ssGetLocalBlockIO(rts))->DataTypeConversion4_k;

12143
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

12144
            _ssSetInputPortNumDimensions(childS, 1, 1);

12145
            ssSetInputPortWidth(childS, 1, 1);

12146
          }

12147


12148
          /* port 2 */

12149
          {

12150
            real32_T const **sfcnUPtrs = (real32_T const **)

12151
              malloc(1 * sizeof(real32_T *));

12152
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12153
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

12154
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

12155
            _ssSetInputPortNumDimensions(childS, 2, 1);

12156
            ssSetInputPortWidth(childS, 2, 1);

12157
          }

12158


12159
          /* port 3 */

12160
          {

12161
            real32_T const **sfcnUPtrs = (real32_T const **)

12162
              malloc(1 * sizeof(real32_T *));

12163
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12164
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

12165
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

12166
            _ssSetInputPortNumDimensions(childS, 3, 1);

12167
            ssSetInputPortWidth(childS, 3, 1);

12168
          }

12169


12170
          /* port 4 */

12171
          {

12172
            real32_T const **sfcnUPtrs = (real32_T const **)

12173
              malloc(1 * sizeof(real32_T *));

12174
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12175
            sfcnUPtrs[0] = (real32_T const *)

12176
              &AFCS_MODEL1_ConstP.Constant19_Value;

12177
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

12178
            _ssSetInputPortNumDimensions(childS, 4, 1);

12179
            ssSetInputPortWidth(childS, 4, 1);

12180
          }

12181


12182
          /* port 5 */

12183
          {

12184
            real32_T const **sfcnUPtrs = (real32_T const **)

12185
              malloc(1 * sizeof(real32_T *));

12186
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12187
            sfcnUPtrs[0] = (real32_T const *)

12188
              &AFCS_MODEL1_ConstP.Constant76_Value;

12189
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

12190
            _ssSetInputPortNumDimensions(childS, 5, 1);

12191
            ssSetInputPortWidth(childS, 5, 1);

12192
          }

12193


12194
          /* port 6 */

12195
          {

12196
            real32_T const **sfcnUPtrs = (real32_T const **)

12197
              malloc(1 * sizeof(real32_T *));

12198
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12199
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12200
              ssGetLocalBlockIO(rts))->GeneratedSFunction_d;

12201
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

12202
            _ssSetInputPortNumDimensions(childS, 6, 1);

12203
            ssSetInputPortWidth(childS, 6, 1);

12204
          }

12205
        }

12206


12207
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

12208
          RegNumOutputPorts);

12209
        ssSetRegNumOutputPortsFcnArg(childS,childS);

12210


12211
        /* outputs */

12212
        {

12213
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

12214
            calloc(1, sizeof(struct _ssPortOutputs));

12215
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

12216
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

12217
          _ssSetNumOutputPorts(childS, 1);

12218


12219
          /* port 0 */

12220
          {

12221
            _ssSetOutputPortNumDimensions(childS, 0, 1);

12222
            ssSetOutputPortWidth(childS, 0, 1);

12223
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

12224
              ssGetLocalBlockIO(rts))->Saturation8));

12225
          }

12226
        }

12227


12228
        /* path info */

12229
        _ssSetModelName(childS, "IntegratorLimited_sf");

12230
        _ssSetPath(childS,

12231
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Integrator Limited1/Generated S-Function3");

12232
        if (ssGetRTModel(rts) == (NULL)) {

12233
          _ssSetParentSS(childS, rts);

12234
          _ssSetRootSS(childS, ssGetRootSS(rts));

12235
        } else {

12236
          ssSetRTModel(childS,ssGetRTModel(rts));

12237
          _ssSetParentSS(childS, (NULL));

12238
          _ssSetRootSS(childS, childS);

12239
        }

12240


12241
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

12242


12243
        /* work vectors */

12244
        {

12245
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

12246
            (4 * sizeof(struct _ssDWorkRecord));

12247
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

12248
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

12249
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

12250
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

12251
          ssSetSFcnDWork(childS, dWorkRecord);

12252
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

12253
          _ssSetNumDWork(childS, 4);

12254


12255
          /* DWORK0 */

12256
          ssSetDWorkWidth(childS, 0, 1);

12257
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

12258
          ssSetDWorkComplexSignal(childS, 0, 0);

12259
          ssSetDWorkUsedAsDState(childS, 0, 1);

12260
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 182))[0]);

12261


12262
          /* DWORK1 */

12263
          ssSetDWorkWidth(childS, 1, 1);

12264
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

12265
          ssSetDWorkComplexSignal(childS, 1, 0);

12266
          ssSetDWorkUsedAsDState(childS, 1, 1);

12267
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 183))[0]);

12268


12269
          /* DWORK2 */

12270
          ssSetDWorkWidth(childS, 2, 1);

12271
          ssSetDWorkDataType(childS, 2,SS_INT8);

12272
          ssSetDWorkComplexSignal(childS, 2, 0);

12273
          ssSetDWorkUsedAsDState(childS, 2, 1);

12274
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 409))[0]);

12275


12276
          /* DWORK3 */

12277
          ssSetDWorkWidth(childS, 3, 1);

12278
          ssSetDWorkDataType(childS, 3,SS_INT8);

12279
          ssSetDWorkComplexSignal(childS, 3, 0);

12280
          ssSetDWorkUsedAsDState(childS, 3, 1);

12281
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 410))[0]);

12282
        }

12283


12284
        (childS)->regDataType.arg1 = ((void *)(childS));

12285
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

12286
          FcnSetErrorStatus);

12287
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

12288
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

12289
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

12290
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

12291


12292
        /* registration */

12293
#if defined(MATLAB_MEX_FILE)

12294


12295
        {

12296
          int_T i;

12297
          mxArray *plhs[1];

12298
          mxArray *prhs[4];

12299
          double *pr;

12300
          volatile int_T *intS = (int_T *)&childS;

12301
          int_T addrlen = sizeof(SimStruct *);

12302
          int_T m = addrlen/sizeof(int_T) + 1;

12303
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

12304
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

12305
          pr = mxGetPr(prhs[1]);

12306
          for (i = 0; i < m - 1; i++) {

12307
            pr[i] = (double)intS[i];

12308
          }

12309


12310
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

12311
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

12312
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

12313


12314
          /* Reset port dimensions info functions because the S-function

12315
           * and accelerator mex-files explicitly set their dimensions,

12316
           * i.e., they are not dynamically sized. For this case, the

12317
           * mex-file is responsible for the dimensions info memory

12318
           * and Simulink should not free it. This is achieved by

12319
           * setting the following two methods to NULL.

12320
           */

12321
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

12322
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

12323


12324
          /*

12325
           * Setup function pointers and call mdlInitializeSizes via

12326
           * simulink.c

12327
           */

12328
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

12329
          mxDestroyArray(plhs[0]);

12330
          mxDestroyArray(prhs[0]);

12331
          mxDestroyArray(prhs[1]);

12332
          mxDestroyArray(prhs[2]);

12333
          mxDestroyArray(prhs[3]);

12334
        }

12335


12336
#else

12337


12338
        {

12339
          IntegratorLimited_sf(childS);

12340
          sfcnInitializeSizes(childS);

12341
        }

12342


12343
#endif

12344


12345
        sfcnInitializeSampleTimes(childS);

12346


12347
        /* adjust sample time */

12348
        ssSetSampleTime(childS, 0, 0.0);

12349
        ssSetOffsetTime(childS, 0, 0.0);

12350
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

12351


12352
        /* set compiled values of dynamic vector attributes */

12353
        ssSetNumNonsampledZCs(childS, 0);

12354


12355
        /* Update connectivity flags for each port */

12356
        _ssSetInputPortConnected(childS, 0, 1);

12357
        _ssSetInputPortConnected(childS, 1, 1);

12358
        _ssSetInputPortConnected(childS, 2, 1);

12359
        _ssSetInputPortConnected(childS, 3, 1);

12360
        _ssSetInputPortConnected(childS, 4, 1);

12361
        _ssSetInputPortConnected(childS, 5, 1);

12362
        _ssSetInputPortConnected(childS, 6, 1);

12363
        _ssSetOutputPortConnected(childS, 0, 1);

12364
        _ssSetOutputPortBeingMerged(childS, 0, 0);

12365


12366
        /* Update the BufferDstPort flags for each input port */

12367
        _ssSetInputPortBufferDstPort(childS, 0, -1);

12368
        _ssSetInputPortBufferDstPort(childS, 1, -1);

12369
        _ssSetInputPortBufferDstPort(childS, 2, -1);

12370
        _ssSetInputPortBufferDstPort(childS, 3, -1);

12371
        _ssSetInputPortBufferDstPort(childS, 4, -1);

12372
        _ssSetInputPortBufferDstPort(childS, 5, -1);

12373
        _ssSetInputPortBufferDstPort(childS, 6, -1);

12374
      }

12375


12376
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S108>/Generated S-Function2 (LeadLagFilter_sf) */

12377
      {

12378
        SimStruct *childS = ssGetSFunction(rts, 46);

12379


12380
        /* timing info */

12381
        time_T *sfcnPeriod;

12382
        time_T *sfcnOffset;

12383
        int_T *sfcnTsMap;

12384
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

12385
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

12386
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

12387
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

12388
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

12389
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

12390
        (void) memset((void*)sfcnPeriod, 0,

12391
                      sizeof(time_T)*1);

12392
        (void) memset((void*)sfcnOffset, 0,

12393
                      sizeof(time_T)*1);

12394
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

12395
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

12396
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

12397


12398
        /* Set up the mdlInfo pointer */

12399
# ifdef USE_RTMODEL

12400


12401
        {

12402
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

12403
              struct _ssBlkInfo2));

12404
          ss_VALIDATE_MEMORY(rts,blkInfo2);

12405
          ssSetBlkInfo2Ptr(childS, blkInfo2);

12406
        }

12407


12408
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

12409


12410
# else

12411


12412
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

12413


12414
# endif                                /* USE_RTMODEL */

12415


12416
        /* Allocate memory of model methods 2 */

12417
        {

12418
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

12419
            malloc(sizeof(struct _ssSFcnModelMethods2));

12420
          ss_VALIDATE_MEMORY(rts,methods2);

12421
          ssSetModelMethods2(childS, methods2);

12422
        }

12423


12424
        /* Allocate memory of model methods 3 */

12425
        {

12426
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

12427
            malloc(sizeof(struct _ssSFcnModelMethods3));

12428
          ss_VALIDATE_MEMORY(rts,methods3);

12429
          ssSetModelMethods3(childS, methods3);

12430
        }

12431


12432
        /* Allocate memory for states auxilliary information */

12433
        {

12434
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

12435
            (sizeof(struct _ssStatesInfo2));

12436
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

12437
            malloc(sizeof(ssPeriodicStatesInfo));

12438
          ss_VALIDATE_MEMORY(rts,statesInfo2);

12439
          ssSetStatesInfo2(childS, statesInfo2);

12440
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

12441
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

12442
        }

12443


12444
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

12445
          RegNumInputPorts);

12446
        ssSetRegNumInputPortsFcnArg(childS,childS);

12447


12448
        /* inputs */

12449
        {

12450
          struct _ssPortInputs *inputPortInfo =

12451
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

12452
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

12453
          _ssSetNumInputPorts(childS, 7);

12454
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

12455


12456
          /* port 0 */

12457
          {

12458
            real32_T const **sfcnUPtrs = (real32_T const **)

12459
              malloc(1 * sizeof(real32_T *));

12460
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12461
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12462
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

12463
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

12464
            _ssSetInputPortNumDimensions(childS, 0, 1);

12465
            ssSetInputPortWidth(childS, 0, 1);

12466
          }

12467


12468
          /* port 1 */

12469
          {

12470
            int8_T const **sfcnUPtrs = (int8_T const **)

12471
              malloc(1 * sizeof(int8_T *));

12472
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12473
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

12474
              ssGetLocalBlockIO(rts))->DataTypeConversion4_k;

12475
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

12476
            _ssSetInputPortNumDimensions(childS, 1, 1);

12477
            ssSetInputPortWidth(childS, 1, 1);

12478
          }

12479


12480
          /* port 2 */

12481
          {

12482
            real32_T const **sfcnUPtrs = (real32_T const **)

12483
              malloc(1 * sizeof(real32_T *));

12484
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12485
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

12486
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

12487
            _ssSetInputPortNumDimensions(childS, 2, 1);

12488
            ssSetInputPortWidth(childS, 2, 1);

12489
          }

12490


12491
          /* port 3 */

12492
          {

12493
            real32_T const **sfcnUPtrs = (real32_T const **)

12494
              malloc(1 * sizeof(real32_T *));

12495
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12496
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;

12497
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

12498
            _ssSetInputPortNumDimensions(childS, 3, 1);

12499
            ssSetInputPortWidth(childS, 3, 1);

12500
          }

12501


12502
          /* port 4 */

12503
          {

12504
            real32_T const **sfcnUPtrs = (real32_T const **)

12505
              malloc(1 * sizeof(real32_T *));

12506
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12507
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12508
              ssGetLocalBlockIO(rts))->Switch_aj;

12509
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

12510
            _ssSetInputPortNumDimensions(childS, 4, 1);

12511
            ssSetInputPortWidth(childS, 4, 1);

12512
          }

12513


12514
          /* port 5 */

12515
          {

12516
            real32_T const **sfcnUPtrs = (real32_T const **)

12517
              malloc(1 * sizeof(real32_T *));

12518
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12519
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12520
              ssGetLocalBlockIO(rts))->Switch_aj;

12521
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

12522
            _ssSetInputPortNumDimensions(childS, 5, 1);

12523
            ssSetInputPortWidth(childS, 5, 1);

12524
          }

12525


12526
          /* port 6 */

12527
          {

12528
            real32_T const **sfcnUPtrs = (real32_T const **)

12529
              malloc(1 * sizeof(real32_T *));

12530
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12531
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12532
              ssGetLocalBlockIO(rts))->Divide_ez;

12533
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

12534
            _ssSetInputPortNumDimensions(childS, 6, 1);

12535
            ssSetInputPortWidth(childS, 6, 1);

12536
          }

12537
        }

12538


12539
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

12540
          RegNumOutputPorts);

12541
        ssSetRegNumOutputPortsFcnArg(childS,childS);

12542


12543
        /* outputs */

12544
        {

12545
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

12546
            calloc(1, sizeof(struct _ssPortOutputs));

12547
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

12548
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

12549
          _ssSetNumOutputPorts(childS, 1);

12550


12551
          /* port 0 */

12552
          {

12553
            _ssSetOutputPortNumDimensions(childS, 0, 1);

12554
            ssSetOutputPortWidth(childS, 0, 1);

12555
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

12556
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_b));

12557
          }

12558
        }

12559


12560
        /* path info */

12561
        _ssSetModelName(childS, "LeadLagFilter_sf");

12562
        _ssSetPath(childS,

12563
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Lead lag/Generated S-Function2");

12564
        if (ssGetRTModel(rts) == (NULL)) {

12565
          _ssSetParentSS(childS, rts);

12566
          _ssSetRootSS(childS, ssGetRootSS(rts));

12567
        } else {

12568
          ssSetRTModel(childS,ssGetRTModel(rts));

12569
          _ssSetParentSS(childS, (NULL));

12570
          _ssSetRootSS(childS, childS);

12571
        }

12572


12573
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

12574


12575
        /* work vectors */

12576
        {

12577
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

12578
            (4 * sizeof(struct _ssDWorkRecord));

12579
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

12580
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

12581
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

12582
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

12583
          ssSetSFcnDWork(childS, dWorkRecord);

12584
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

12585
          _ssSetNumDWork(childS, 4);

12586


12587
          /* DWORK0 */

12588
          ssSetDWorkWidth(childS, 0, 1);

12589
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

12590
          ssSetDWorkComplexSignal(childS, 0, 0);

12591
          ssSetDWorkUsedAsDState(childS, 0, 1);

12592
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 184))[0]);

12593


12594
          /* DWORK1 */

12595
          ssSetDWorkWidth(childS, 1, 1);

12596
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

12597
          ssSetDWorkComplexSignal(childS, 1, 0);

12598
          ssSetDWorkUsedAsDState(childS, 1, 1);

12599
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 185))[0]);

12600


12601
          /* DWORK2 */

12602
          ssSetDWorkWidth(childS, 2, 1);

12603
          ssSetDWorkDataType(childS, 2,SS_INT8);

12604
          ssSetDWorkComplexSignal(childS, 2, 0);

12605
          ssSetDWorkUsedAsDState(childS, 2, 1);

12606
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 411))[0]);

12607


12608
          /* DWORK3 */

12609
          ssSetDWorkWidth(childS, 3, 1);

12610
          ssSetDWorkDataType(childS, 3,SS_INT8);

12611
          ssSetDWorkComplexSignal(childS, 3, 0);

12612
          ssSetDWorkUsedAsDState(childS, 3, 1);

12613
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 412))[0]);

12614
        }

12615


12616
        (childS)->regDataType.arg1 = ((void *)(childS));

12617
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

12618
          FcnSetErrorStatus);

12619
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

12620
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

12621
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

12622
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

12623


12624
        /* registration */

12625
#if defined(MATLAB_MEX_FILE)

12626


12627
        {

12628
          int_T i;

12629
          mxArray *plhs[1];

12630
          mxArray *prhs[4];

12631
          double *pr;

12632
          volatile int_T *intS = (int_T *)&childS;

12633
          int_T addrlen = sizeof(SimStruct *);

12634
          int_T m = addrlen/sizeof(int_T) + 1;

12635
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

12636
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

12637
          pr = mxGetPr(prhs[1]);

12638
          for (i = 0; i < m - 1; i++) {

12639
            pr[i] = (double)intS[i];

12640
          }

12641


12642
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

12643
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

12644
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

12645


12646
          /* Reset port dimensions info functions because the S-function

12647
           * and accelerator mex-files explicitly set their dimensions,

12648
           * i.e., they are not dynamically sized. For this case, the

12649
           * mex-file is responsible for the dimensions info memory

12650
           * and Simulink should not free it. This is achieved by

12651
           * setting the following two methods to NULL.

12652
           */

12653
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

12654
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

12655


12656
          /*

12657
           * Setup function pointers and call mdlInitializeSizes via

12658
           * simulink.c

12659
           */

12660
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

12661
          mxDestroyArray(plhs[0]);

12662
          mxDestroyArray(prhs[0]);

12663
          mxDestroyArray(prhs[1]);

12664
          mxDestroyArray(prhs[2]);

12665
          mxDestroyArray(prhs[3]);

12666
        }

12667


12668
#else

12669


12670
        {

12671
          LeadLagFilter_sf(childS);

12672
          sfcnInitializeSizes(childS);

12673
        }

12674


12675
#endif

12676


12677
        sfcnInitializeSampleTimes(childS);

12678


12679
        /* adjust sample time */

12680
        ssSetSampleTime(childS, 0, 0.0);

12681
        ssSetOffsetTime(childS, 0, 0.0);

12682
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

12683


12684
        /* set compiled values of dynamic vector attributes */

12685
        ssSetNumNonsampledZCs(childS, 0);

12686


12687
        /* Update connectivity flags for each port */

12688
        _ssSetInputPortConnected(childS, 0, 1);

12689
        _ssSetInputPortConnected(childS, 1, 1);

12690
        _ssSetInputPortConnected(childS, 2, 1);

12691
        _ssSetInputPortConnected(childS, 3, 1);

12692
        _ssSetInputPortConnected(childS, 4, 1);

12693
        _ssSetInputPortConnected(childS, 5, 1);

12694
        _ssSetInputPortConnected(childS, 6, 1);

12695
        _ssSetOutputPortConnected(childS, 0, 1);

12696
        _ssSetOutputPortBeingMerged(childS, 0, 0);

12697


12698
        /* Update the BufferDstPort flags for each input port */

12699
        _ssSetInputPortBufferDstPort(childS, 0, -1);

12700
        _ssSetInputPortBufferDstPort(childS, 1, -1);

12701
        _ssSetInputPortBufferDstPort(childS, 2, -1);

12702
        _ssSetInputPortBufferDstPort(childS, 3, -1);

12703
        _ssSetInputPortBufferDstPort(childS, 4, -1);

12704
        _ssSetInputPortBufferDstPort(childS, 5, -1);

12705
        _ssSetInputPortBufferDstPort(childS, 6, -1);

12706
      }

12707


12708
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S110>/Generated S-Function1 (SaturationLimiter_sf) */

12709
      {

12710
        SimStruct *childS = ssGetSFunction(rts, 47);

12711


12712
        /* timing info */

12713
        time_T *sfcnPeriod;

12714
        time_T *sfcnOffset;

12715
        int_T *sfcnTsMap;

12716
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

12717
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

12718
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

12719
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

12720
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

12721
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

12722
        (void) memset((void*)sfcnPeriod, 0,

12723
                      sizeof(time_T)*1);

12724
        (void) memset((void*)sfcnOffset, 0,

12725
                      sizeof(time_T)*1);

12726
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

12727
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

12728
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

12729


12730
        /* Set up the mdlInfo pointer */

12731
# ifdef USE_RTMODEL

12732


12733
        {

12734
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

12735
              struct _ssBlkInfo2));

12736
          ss_VALIDATE_MEMORY(rts,blkInfo2);

12737
          ssSetBlkInfo2Ptr(childS, blkInfo2);

12738
        }

12739


12740
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

12741


12742
# else

12743


12744
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

12745


12746
# endif                                /* USE_RTMODEL */

12747


12748
        /* Allocate memory of model methods 2 */

12749
        {

12750
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

12751
            malloc(sizeof(struct _ssSFcnModelMethods2));

12752
          ss_VALIDATE_MEMORY(rts,methods2);

12753
          ssSetModelMethods2(childS, methods2);

12754
        }

12755


12756
        /* Allocate memory of model methods 3 */

12757
        {

12758
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

12759
            malloc(sizeof(struct _ssSFcnModelMethods3));

12760
          ss_VALIDATE_MEMORY(rts,methods3);

12761
          ssSetModelMethods3(childS, methods3);

12762
        }

12763


12764
        /* Allocate memory for states auxilliary information */

12765
        {

12766
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

12767
            (sizeof(struct _ssStatesInfo2));

12768
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

12769
            malloc(sizeof(ssPeriodicStatesInfo));

12770
          ss_VALIDATE_MEMORY(rts,statesInfo2);

12771
          ssSetStatesInfo2(childS, statesInfo2);

12772
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

12773
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

12774
        }

12775


12776
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

12777
          RegNumInputPorts);

12778
        ssSetRegNumInputPortsFcnArg(childS,childS);

12779


12780
        /* inputs */

12781
        {

12782
          struct _ssPortInputs *inputPortInfo =

12783
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

12784
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

12785
          _ssSetNumInputPorts(childS, 3);

12786
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

12787


12788
          /* port 0 */

12789
          {

12790
            real32_T const **sfcnUPtrs = (real32_T const **)

12791
              malloc(1 * sizeof(real32_T *));

12792
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12793
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12794
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_b;

12795
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

12796
            _ssSetInputPortNumDimensions(childS, 0, 1);

12797
            ssSetInputPortWidth(childS, 0, 1);

12798
          }

12799


12800
          /* port 1 */

12801
          {

12802
            real32_T const **sfcnUPtrs = (real32_T const **)

12803
              malloc(1 * sizeof(real32_T *));

12804
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12805
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12806
              ssGetLocalBlockIO(rts))->Product1_m;

12807
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

12808
            _ssSetInputPortNumDimensions(childS, 1, 1);

12809
            ssSetInputPortWidth(childS, 1, 1);

12810
          }

12811


12812
          /* port 2 */

12813
          {

12814
            real32_T const **sfcnUPtrs = (real32_T const **)

12815
              malloc(1 * sizeof(real32_T *));

12816
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

12817
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

12818
              ssGetLocalBlockIO(rts))->Product_pp;

12819
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

12820
            _ssSetInputPortNumDimensions(childS, 2, 1);

12821
            ssSetInputPortWidth(childS, 2, 1);

12822
          }

12823
        }

12824


12825
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

12826
          RegNumOutputPorts);

12827
        ssSetRegNumOutputPortsFcnArg(childS,childS);

12828


12829
        /* outputs */

12830
        {

12831
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

12832
            calloc(1, sizeof(struct _ssPortOutputs));

12833
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

12834
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

12835
          _ssSetNumOutputPorts(childS, 1);

12836


12837
          /* port 0 */

12838
          {

12839
            _ssSetOutputPortNumDimensions(childS, 0, 1);

12840
            ssSetOutputPortWidth(childS, 0, 1);

12841
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

12842
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_l));

12843
          }

12844
        }

12845


12846
        /* path info */

12847
        _ssSetModelName(childS, "SaturationLimiter_sf");

12848
        _ssSetPath(childS,

12849
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Saturation Limiter2/Generated S-Function1");

12850
        if (ssGetRTModel(rts) == (NULL)) {

12851
          _ssSetParentSS(childS, rts);

12852
          _ssSetRootSS(childS, ssGetRootSS(rts));

12853
        } else {

12854
          ssSetRTModel(childS,ssGetRTModel(rts));

12855
          _ssSetParentSS(childS, (NULL));

12856
          _ssSetRootSS(childS, childS);

12857
        }

12858


12859
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

12860
        (childS)->regDataType.arg1 = ((void *)(childS));

12861
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

12862
          FcnSetErrorStatus);

12863
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

12864
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

12865
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

12866
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

12867


12868
        /* registration */

12869
#if defined(MATLAB_MEX_FILE)

12870


12871
        {

12872
          int_T i;

12873
          mxArray *plhs[1];

12874
          mxArray *prhs[4];

12875
          double *pr;

12876
          volatile int_T *intS = (int_T *)&childS;

12877
          int_T addrlen = sizeof(SimStruct *);

12878
          int_T m = addrlen/sizeof(int_T) + 1;

12879
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

12880
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

12881
          pr = mxGetPr(prhs[1]);

12882
          for (i = 0; i < m - 1; i++) {

12883
            pr[i] = (double)intS[i];

12884
          }

12885


12886
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

12887
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

12888
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

12889


12890
          /* Reset port dimensions info functions because the S-function

12891
           * and accelerator mex-files explicitly set their dimensions,

12892
           * i.e., they are not dynamically sized. For this case, the

12893
           * mex-file is responsible for the dimensions info memory

12894
           * and Simulink should not free it. This is achieved by

12895
           * setting the following two methods to NULL.

12896
           */

12897
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

12898
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

12899


12900
          /*

12901
           * Setup function pointers and call mdlInitializeSizes via

12902
           * simulink.c

12903
           */

12904
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

12905
          mxDestroyArray(plhs[0]);

12906
          mxDestroyArray(prhs[0]);

12907
          mxDestroyArray(prhs[1]);

12908
          mxDestroyArray(prhs[2]);

12909
          mxDestroyArray(prhs[3]);

12910
        }

12911


12912
#else

12913


12914
        {

12915
          SaturationLimiter_sf(childS);

12916
          sfcnInitializeSizes(childS);

12917
        }

12918


12919
#endif

12920


12921
        sfcnInitializeSampleTimes(childS);

12922


12923
        /* adjust sample time */

12924
        ssSetSampleTime(childS, 0, 0.0);

12925
        ssSetOffsetTime(childS, 0, 0.0);

12926
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

12927


12928
        /* set compiled values of dynamic vector attributes */

12929
        ssSetNumNonsampledZCs(childS, 0);

12930


12931
        /* Update connectivity flags for each port */

12932
        _ssSetInputPortConnected(childS, 0, 1);

12933
        _ssSetInputPortConnected(childS, 1, 1);

12934
        _ssSetInputPortConnected(childS, 2, 1);

12935
        _ssSetOutputPortConnected(childS, 0, 1);

12936
        _ssSetOutputPortBeingMerged(childS, 0, 0);

12937


12938
        /* Update the BufferDstPort flags for each input port */

12939
        _ssSetInputPortBufferDstPort(childS, 0, -1);

12940
        _ssSetInputPortBufferDstPort(childS, 1, -1);

12941
        _ssSetInputPortBufferDstPort(childS, 2, -1);

12942
      }

12943


12944
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S106>/Generated S-Function4 (LagFilter_sf) */

12945
      {

12946
        SimStruct *childS = ssGetSFunction(rts, 48);

12947


12948
        /* timing info */

12949
        time_T *sfcnPeriod;

12950
        time_T *sfcnOffset;

12951
        int_T *sfcnTsMap;

12952
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

12953
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

12954
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

12955
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

12956
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

12957
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

12958
        (void) memset((void*)sfcnPeriod, 0,

12959
                      sizeof(time_T)*1);

12960
        (void) memset((void*)sfcnOffset, 0,

12961
                      sizeof(time_T)*1);

12962
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

12963
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

12964
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

12965


12966
        /* Set up the mdlInfo pointer */

12967
# ifdef USE_RTMODEL

12968


12969
        {

12970
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

12971
              struct _ssBlkInfo2));

12972
          ss_VALIDATE_MEMORY(rts,blkInfo2);

12973
          ssSetBlkInfo2Ptr(childS, blkInfo2);

12974
        }

12975


12976
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

12977


12978
# else

12979


12980
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

12981


12982
# endif                                /* USE_RTMODEL */

12983


12984
        /* Allocate memory of model methods 2 */

12985
        {

12986
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

12987
            malloc(sizeof(struct _ssSFcnModelMethods2));

12988
          ss_VALIDATE_MEMORY(rts,methods2);

12989
          ssSetModelMethods2(childS, methods2);

12990
        }

12991


12992
        /* Allocate memory of model methods 3 */

12993
        {

12994
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

12995
            malloc(sizeof(struct _ssSFcnModelMethods3));

12996
          ss_VALIDATE_MEMORY(rts,methods3);

12997
          ssSetModelMethods3(childS, methods3);

12998
        }

12999


13000
        /* Allocate memory for states auxilliary information */

13001
        {

13002
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

13003
            (sizeof(struct _ssStatesInfo2));

13004
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

13005
            malloc(sizeof(ssPeriodicStatesInfo));

13006
          ss_VALIDATE_MEMORY(rts,statesInfo2);

13007
          ssSetStatesInfo2(childS, statesInfo2);

13008
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

13009
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

13010
        }

13011


13012
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

13013
          RegNumInputPorts);

13014
        ssSetRegNumInputPortsFcnArg(childS,childS);

13015


13016
        /* inputs */

13017
        {

13018
          struct _ssPortInputs *inputPortInfo =

13019
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

13020
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

13021
          _ssSetNumInputPorts(childS, 6);

13022
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

13023


13024
          /* port 0 */

13025
          {

13026
            real32_T const **sfcnUPtrs = (real32_T const **)

13027
              malloc(1 * sizeof(real32_T *));

13028
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13029
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13030
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

13031
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

13032
            _ssSetInputPortNumDimensions(childS, 0, 1);

13033
            ssSetInputPortWidth(childS, 0, 1);

13034
          }

13035


13036
          /* port 1 */

13037
          {

13038
            int8_T const **sfcnUPtrs = (int8_T const **)

13039
              malloc(1 * sizeof(int8_T *));

13040
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13041
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

13042
              ssGetLocalBlockIO(rts))->DataTypeConversion4_k;

13043
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

13044
            _ssSetInputPortNumDimensions(childS, 1, 1);

13045
            ssSetInputPortWidth(childS, 1, 1);

13046
          }

13047


13048
          /* port 2 */

13049
          {

13050
            real32_T const **sfcnUPtrs = (real32_T const **)

13051
              malloc(1 * sizeof(real32_T *));

13052
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13053
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

13054
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

13055
            _ssSetInputPortNumDimensions(childS, 2, 1);

13056
            ssSetInputPortWidth(childS, 2, 1);

13057
          }

13058


13059
          /* port 3 */

13060
          {

13061
            real32_T const **sfcnUPtrs = (real32_T const **)

13062
              malloc(1 * sizeof(real32_T *));

13063
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13064
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13065
              ssGetLocalBlockIO(rts))->Switch_aj;

13066
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

13067
            _ssSetInputPortNumDimensions(childS, 3, 1);

13068
            ssSetInputPortWidth(childS, 3, 1);

13069
          }

13070


13071
          /* port 4 */

13072
          {

13073
            real32_T const **sfcnUPtrs = (real32_T const **)

13074
              malloc(1 * sizeof(real32_T *));

13075
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13076
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13077
              ssGetLocalBlockIO(rts))->Switch_aj;

13078
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

13079
            _ssSetInputPortNumDimensions(childS, 4, 1);

13080
            ssSetInputPortWidth(childS, 4, 1);

13081
          }

13082


13083
          /* port 5 */

13084
          {

13085
            real32_T const **sfcnUPtrs = (real32_T const **)

13086
              malloc(1 * sizeof(real32_T *));

13087
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13088
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13089
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_l;

13090
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

13091
            _ssSetInputPortNumDimensions(childS, 5, 1);

13092
            ssSetInputPortWidth(childS, 5, 1);

13093
          }

13094
        }

13095


13096
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

13097
          RegNumOutputPorts);

13098
        ssSetRegNumOutputPortsFcnArg(childS,childS);

13099


13100
        /* outputs */

13101
        {

13102
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

13103
            calloc(1, sizeof(struct _ssPortOutputs));

13104
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

13105
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

13106
          _ssSetNumOutputPorts(childS, 1);

13107


13108
          /* port 0 */

13109
          {

13110
            _ssSetOutputPortNumDimensions(childS, 0, 1);

13111
            ssSetOutputPortWidth(childS, 0, 1);

13112
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

13113
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_n));

13114
          }

13115
        }

13116


13117
        /* path info */

13118
        _ssSetModelName(childS, "LagFilter_sf");

13119
        _ssSetPath(childS,

13120
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/ lag filter/Generated S-Function4");

13121
        if (ssGetRTModel(rts) == (NULL)) {

13122
          _ssSetParentSS(childS, rts);

13123
          _ssSetRootSS(childS, ssGetRootSS(rts));

13124
        } else {

13125
          ssSetRTModel(childS,ssGetRTModel(rts));

13126
          _ssSetParentSS(childS, (NULL));

13127
          _ssSetRootSS(childS, childS);

13128
        }

13129


13130
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

13131


13132
        /* work vectors */

13133
        {

13134
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

13135
            (4 * sizeof(struct _ssDWorkRecord));

13136
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

13137
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

13138
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

13139
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

13140
          ssSetSFcnDWork(childS, dWorkRecord);

13141
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

13142
          _ssSetNumDWork(childS, 4);

13143


13144
          /* DWORK0 */

13145
          ssSetDWorkWidth(childS, 0, 1);

13146
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

13147
          ssSetDWorkComplexSignal(childS, 0, 0);

13148
          ssSetDWorkUsedAsDState(childS, 0, 1);

13149
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 186))[0]);

13150


13151
          /* DWORK1 */

13152
          ssSetDWorkWidth(childS, 1, 1);

13153
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

13154
          ssSetDWorkComplexSignal(childS, 1, 0);

13155
          ssSetDWorkUsedAsDState(childS, 1, 1);

13156
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 187))[0]);

13157


13158
          /* DWORK2 */

13159
          ssSetDWorkWidth(childS, 2, 1);

13160
          ssSetDWorkDataType(childS, 2,SS_INT8);

13161
          ssSetDWorkComplexSignal(childS, 2, 0);

13162
          ssSetDWorkUsedAsDState(childS, 2, 1);

13163
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 413))[0]);

13164


13165
          /* DWORK3 */

13166
          ssSetDWorkWidth(childS, 3, 1);

13167
          ssSetDWorkDataType(childS, 3,SS_INT8);

13168
          ssSetDWorkComplexSignal(childS, 3, 0);

13169
          ssSetDWorkUsedAsDState(childS, 3, 1);

13170
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 414))[0]);

13171
        }

13172


13173
        (childS)->regDataType.arg1 = ((void *)(childS));

13174
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

13175
          FcnSetErrorStatus);

13176
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

13177
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

13178
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

13179
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

13180


13181
        /* registration */

13182
#if defined(MATLAB_MEX_FILE)

13183


13184
        {

13185
          int_T i;

13186
          mxArray *plhs[1];

13187
          mxArray *prhs[4];

13188
          double *pr;

13189
          volatile int_T *intS = (int_T *)&childS;

13190
          int_T addrlen = sizeof(SimStruct *);

13191
          int_T m = addrlen/sizeof(int_T) + 1;

13192
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

13193
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

13194
          pr = mxGetPr(prhs[1]);

13195
          for (i = 0; i < m - 1; i++) {

13196
            pr[i] = (double)intS[i];

13197
          }

13198


13199
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

13200
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

13201
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

13202


13203
          /* Reset port dimensions info functions because the S-function

13204
           * and accelerator mex-files explicitly set their dimensions,

13205
           * i.e., they are not dynamically sized. For this case, the

13206
           * mex-file is responsible for the dimensions info memory

13207
           * and Simulink should not free it. This is achieved by

13208
           * setting the following two methods to NULL.

13209
           */

13210
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

13211
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

13212


13213
          /*

13214
           * Setup function pointers and call mdlInitializeSizes via

13215
           * simulink.c

13216
           */

13217
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

13218
          mxDestroyArray(plhs[0]);

13219
          mxDestroyArray(prhs[0]);

13220
          mxDestroyArray(prhs[1]);

13221
          mxDestroyArray(prhs[2]);

13222
          mxDestroyArray(prhs[3]);

13223
        }

13224


13225
#else

13226


13227
        {

13228
          LagFilter_sf(childS);

13229
          sfcnInitializeSizes(childS);

13230
        }

13231


13232
#endif

13233


13234
        sfcnInitializeSampleTimes(childS);

13235


13236
        /* adjust sample time */

13237
        ssSetSampleTime(childS, 0, 0.0);

13238
        ssSetOffsetTime(childS, 0, 0.0);

13239
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

13240


13241
        /* set compiled values of dynamic vector attributes */

13242
        ssSetNumNonsampledZCs(childS, 0);

13243


13244
        /* Update connectivity flags for each port */

13245
        _ssSetInputPortConnected(childS, 0, 1);

13246
        _ssSetInputPortConnected(childS, 1, 1);

13247
        _ssSetInputPortConnected(childS, 2, 1);

13248
        _ssSetInputPortConnected(childS, 3, 1);

13249
        _ssSetInputPortConnected(childS, 4, 1);

13250
        _ssSetInputPortConnected(childS, 5, 1);

13251
        _ssSetOutputPortConnected(childS, 0, 1);

13252
        _ssSetOutputPortBeingMerged(childS, 0, 0);

13253


13254
        /* Update the BufferDstPort flags for each input port */

13255
        _ssSetInputPortBufferDstPort(childS, 0, -1);

13256
        _ssSetInputPortBufferDstPort(childS, 1, -1);

13257
        _ssSetInputPortBufferDstPort(childS, 2, -1);

13258
        _ssSetInputPortBufferDstPort(childS, 3, -1);

13259
        _ssSetInputPortBufferDstPort(childS, 4, -1);

13260
        _ssSetInputPortBufferDstPort(childS, 5, -1);

13261
      }

13262


13263
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S81>/Generated S-Function5 (Fader_sf) */

13264
      {

13265
        SimStruct *childS = ssGetSFunction(rts, 49);

13266


13267
        /* timing info */

13268
        time_T *sfcnPeriod;

13269
        time_T *sfcnOffset;

13270
        int_T *sfcnTsMap;

13271
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

13272
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

13273
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

13274
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

13275
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

13276
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

13277
        (void) memset((void*)sfcnPeriod, 0,

13278
                      sizeof(time_T)*1);

13279
        (void) memset((void*)sfcnOffset, 0,

13280
                      sizeof(time_T)*1);

13281
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

13282
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

13283
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

13284


13285
        /* Set up the mdlInfo pointer */

13286
# ifdef USE_RTMODEL

13287


13288
        {

13289
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

13290
              struct _ssBlkInfo2));

13291
          ss_VALIDATE_MEMORY(rts,blkInfo2);

13292
          ssSetBlkInfo2Ptr(childS, blkInfo2);

13293
        }

13294


13295
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

13296


13297
# else

13298


13299
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

13300


13301
# endif                                /* USE_RTMODEL */

13302


13303
        /* Allocate memory of model methods 2 */

13304
        {

13305
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

13306
            malloc(sizeof(struct _ssSFcnModelMethods2));

13307
          ss_VALIDATE_MEMORY(rts,methods2);

13308
          ssSetModelMethods2(childS, methods2);

13309
        }

13310


13311
        /* Allocate memory of model methods 3 */

13312
        {

13313
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

13314
            malloc(sizeof(struct _ssSFcnModelMethods3));

13315
          ss_VALIDATE_MEMORY(rts,methods3);

13316
          ssSetModelMethods3(childS, methods3);

13317
        }

13318


13319
        /* Allocate memory for states auxilliary information */

13320
        {

13321
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

13322
            (sizeof(struct _ssStatesInfo2));

13323
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

13324
            malloc(sizeof(ssPeriodicStatesInfo));

13325
          ss_VALIDATE_MEMORY(rts,statesInfo2);

13326
          ssSetStatesInfo2(childS, statesInfo2);

13327
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

13328
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

13329
        }

13330


13331
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

13332
          RegNumInputPorts);

13333
        ssSetRegNumInputPortsFcnArg(childS,childS);

13334


13335
        /* inputs */

13336
        {

13337
          struct _ssPortInputs *inputPortInfo =

13338
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

13339
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

13340
          _ssSetNumInputPorts(childS, 6);

13341
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

13342


13343
          /* port 0 */

13344
          {

13345
            real32_T const **sfcnUPtrs = (real32_T const **)

13346
              malloc(1 * sizeof(real32_T *));

13347
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13348
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13349
              ssGetLocalBlockIO(rts))->MultiportSwitch2;

13350
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

13351
            _ssSetInputPortNumDimensions(childS, 0, 1);

13352
            ssSetInputPortWidth(childS, 0, 1);

13353
          }

13354


13355
          /* port 1 */

13356
          {

13357
            real32_T const **sfcnUPtrs = (real32_T const **)

13358
              malloc(1 * sizeof(real32_T *));

13359
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13360
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13361
              ssGetLocalBlockIO(rts))->MultiportSwitch2;

13362
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

13363
            _ssSetInputPortNumDimensions(childS, 1, 1);

13364
            ssSetInputPortWidth(childS, 1, 1);

13365
          }

13366


13367
          /* port 2 */

13368
          {

13369
            int8_T const **sfcnUPtrs = (int8_T const **)

13370
              malloc(1 * sizeof(int8_T *));

13371
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13372
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

13373
              ssGetLocalBlockIO(rts))->Switch9;

13374
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

13375
            _ssSetInputPortNumDimensions(childS, 2, 1);

13376
            ssSetInputPortWidth(childS, 2, 1);

13377
          }

13378


13379
          /* port 3 */

13380
          {

13381
            int8_T const **sfcnUPtrs = (int8_T const **)

13382
              malloc(1 * sizeof(int8_T *));

13383
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13384
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

13385
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

13386
            _ssSetInputPortNumDimensions(childS, 3, 1);

13387
            ssSetInputPortWidth(childS, 3, 1);

13388
          }

13389


13390
          /* port 4 */

13391
          {

13392
            real32_T const **sfcnUPtrs = (real32_T const **)

13393
              malloc(1 * sizeof(real32_T *));

13394
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13395
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

13396
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

13397
            _ssSetInputPortNumDimensions(childS, 4, 1);

13398
            ssSetInputPortWidth(childS, 4, 1);

13399
          }

13400


13401
          /* port 5 */

13402
          {

13403
            real32_T const **sfcnUPtrs = (real32_T const **)

13404
              malloc(1 * sizeof(real32_T *));

13405
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13406
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13407
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

13408
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

13409
            _ssSetInputPortNumDimensions(childS, 5, 1);

13410
            ssSetInputPortWidth(childS, 5, 1);

13411
          }

13412
        }

13413


13414
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

13415
          RegNumOutputPorts);

13416
        ssSetRegNumOutputPortsFcnArg(childS,childS);

13417


13418
        /* outputs */

13419
        {

13420
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

13421
            calloc(1, sizeof(struct _ssPortOutputs));

13422
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

13423
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

13424
          _ssSetNumOutputPorts(childS, 1);

13425


13426
          /* port 0 */

13427
          {

13428
            _ssSetOutputPortNumDimensions(childS, 0, 1);

13429
            ssSetOutputPortWidth(childS, 0, 1);

13430
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

13431
              ssGetLocalBlockIO(rts))->appc));

13432
          }

13433
        }

13434


13435
        /* path info */

13436
        _ssSetModelName(childS, "Fader_sf");

13437
        _ssSetPath(childS,

13438
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/Fader/Generated S-Function5");

13439
        if (ssGetRTModel(rts) == (NULL)) {

13440
          _ssSetParentSS(childS, rts);

13441
          _ssSetRootSS(childS, ssGetRootSS(rts));

13442
        } else {

13443
          ssSetRTModel(childS,ssGetRTModel(rts));

13444
          _ssSetParentSS(childS, (NULL));

13445
          _ssSetRootSS(childS, childS);

13446
        }

13447


13448
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

13449


13450
        /* work vectors */

13451
        {

13452
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

13453
            (7 * sizeof(struct _ssDWorkRecord));

13454
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

13455
            calloc(7, sizeof(struct _ssDWorkAuxRecord));

13456
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

13457
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

13458
          ssSetSFcnDWork(childS, dWorkRecord);

13459
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

13460
          _ssSetNumDWork(childS, 7);

13461


13462
          /* DWORK0 */

13463
          ssSetDWorkWidth(childS, 0, 1);

13464
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

13465
          ssSetDWorkComplexSignal(childS, 0, 0);

13466
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 289))[0]);

13467


13468
          /* DWORK1 */

13469
          ssSetDWorkWidth(childS, 1, 1);

13470
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

13471
          ssSetDWorkComplexSignal(childS, 1, 0);

13472
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 290))[0]);

13473


13474
          /* DWORK2 */

13475
          ssSetDWorkWidth(childS, 2, 1);

13476
          ssSetDWorkDataType(childS, 2,SS_SINGLE);

13477
          ssSetDWorkComplexSignal(childS, 2, 0);

13478
          _ssSetDWork(childS, 2, &((real32_T*) ssGetDWork(rts, 291))[0]);

13479


13480
          /* DWORK3 */

13481
          ssSetDWorkWidth(childS, 3, 1);

13482
          ssSetDWorkDataType(childS, 3,SS_INT32);

13483
          ssSetDWorkComplexSignal(childS, 3, 0);

13484
          _ssSetDWork(childS, 3, &((int32_T*) ssGetDWork(rts, 332))[0]);

13485


13486
          /* DWORK4 */

13487
          ssSetDWorkWidth(childS, 4, 1);

13488
          ssSetDWorkDataType(childS, 4,SS_INT32);

13489
          ssSetDWorkComplexSignal(childS, 4, 0);

13490
          _ssSetDWork(childS, 4, &((int32_T*) ssGetDWork(rts, 333))[0]);

13491


13492
          /* DWORK5 */

13493
          ssSetDWorkWidth(childS, 5, 1);

13494
          ssSetDWorkDataType(childS, 5,SS_INT8);

13495
          ssSetDWorkComplexSignal(childS, 5, 0);

13496
          _ssSetDWork(childS, 5, &((int8_T*) ssGetDWork(rts, 517))[0]);

13497


13498
          /* DWORK6 */

13499
          ssSetDWorkWidth(childS, 6, 1);

13500
          ssSetDWorkDataType(childS, 6,SS_INT8);

13501
          ssSetDWorkComplexSignal(childS, 6, 0);

13502
          _ssSetDWork(childS, 6, &((int8_T*) ssGetDWork(rts, 518))[0]);

13503
        }

13504


13505
        (childS)->regDataType.arg1 = ((void *)(childS));

13506
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

13507
          FcnSetErrorStatus);

13508
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

13509
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

13510
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

13511
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

13512


13513
        /* registration */

13514
#if defined(MATLAB_MEX_FILE)

13515


13516
        {

13517
          int_T i;

13518
          mxArray *plhs[1];

13519
          mxArray *prhs[4];

13520
          double *pr;

13521
          volatile int_T *intS = (int_T *)&childS;

13522
          int_T addrlen = sizeof(SimStruct *);

13523
          int_T m = addrlen/sizeof(int_T) + 1;

13524
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

13525
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

13526
          pr = mxGetPr(prhs[1]);

13527
          for (i = 0; i < m - 1; i++) {

13528
            pr[i] = (double)intS[i];

13529
          }

13530


13531
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

13532
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

13533
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

13534


13535
          /* Reset port dimensions info functions because the S-function

13536
           * and accelerator mex-files explicitly set their dimensions,

13537
           * i.e., they are not dynamically sized. For this case, the

13538
           * mex-file is responsible for the dimensions info memory

13539
           * and Simulink should not free it. This is achieved by

13540
           * setting the following two methods to NULL.

13541
           */

13542
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

13543
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

13544


13545
          /*

13546
           * Setup function pointers and call mdlInitializeSizes via

13547
           * simulink.c

13548
           */

13549
          mexCallMATLAB(1, plhs, 4, prhs, "Fader_sf");

13550
          mxDestroyArray(plhs[0]);

13551
          mxDestroyArray(prhs[0]);

13552
          mxDestroyArray(prhs[1]);

13553
          mxDestroyArray(prhs[2]);

13554
          mxDestroyArray(prhs[3]);

13555
        }

13556


13557
#else

13558


13559
        {

13560
          Fader_sf(childS);

13561
          sfcnInitializeSizes(childS);

13562
        }

13563


13564
#endif

13565


13566
        sfcnInitializeSampleTimes(childS);

13567


13568
        /* adjust sample time */

13569
        ssSetSampleTime(childS, 0, 0.0);

13570
        ssSetOffsetTime(childS, 0, 0.0);

13571
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

13572


13573
        /* set compiled values of dynamic vector attributes */

13574
        ssSetNumNonsampledZCs(childS, 0);

13575


13576
        /* Update connectivity flags for each port */

13577
        _ssSetInputPortConnected(childS, 0, 1);

13578
        _ssSetInputPortConnected(childS, 1, 1);

13579
        _ssSetInputPortConnected(childS, 2, 1);

13580
        _ssSetInputPortConnected(childS, 3, 1);

13581
        _ssSetInputPortConnected(childS, 4, 1);

13582
        _ssSetInputPortConnected(childS, 5, 1);

13583
        _ssSetOutputPortConnected(childS, 0, 1);

13584
        _ssSetOutputPortBeingMerged(childS, 0, 0);

13585


13586
        /* Update the BufferDstPort flags for each input port */

13587
        _ssSetInputPortBufferDstPort(childS, 0, -1);

13588
        _ssSetInputPortBufferDstPort(childS, 1, -1);

13589
        _ssSetInputPortBufferDstPort(childS, 2, -1);

13590
        _ssSetInputPortBufferDstPort(childS, 3, -1);

13591
        _ssSetInputPortBufferDstPort(childS, 4, -1);

13592
        _ssSetInputPortBufferDstPort(childS, 5, -1);

13593
      }

13594


13595
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S130>/Generated S-Function4 (LagFilter_sf) */

13596
      {

13597
        SimStruct *childS = ssGetSFunction(rts, 50);

13598


13599
        /* timing info */

13600
        time_T *sfcnPeriod;

13601
        time_T *sfcnOffset;

13602
        int_T *sfcnTsMap;

13603
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

13604
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

13605
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

13606
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

13607
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

13608
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

13609
        (void) memset((void*)sfcnPeriod, 0,

13610
                      sizeof(time_T)*1);

13611
        (void) memset((void*)sfcnOffset, 0,

13612
                      sizeof(time_T)*1);

13613
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

13614
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

13615
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

13616


13617
        /* Set up the mdlInfo pointer */

13618
# ifdef USE_RTMODEL

13619


13620
        {

13621
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

13622
              struct _ssBlkInfo2));

13623
          ss_VALIDATE_MEMORY(rts,blkInfo2);

13624
          ssSetBlkInfo2Ptr(childS, blkInfo2);

13625
        }

13626


13627
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

13628


13629
# else

13630


13631
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

13632


13633
# endif                                /* USE_RTMODEL */

13634


13635
        /* Allocate memory of model methods 2 */

13636
        {

13637
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

13638
            malloc(sizeof(struct _ssSFcnModelMethods2));

13639
          ss_VALIDATE_MEMORY(rts,methods2);

13640
          ssSetModelMethods2(childS, methods2);

13641
        }

13642


13643
        /* Allocate memory of model methods 3 */

13644
        {

13645
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

13646
            malloc(sizeof(struct _ssSFcnModelMethods3));

13647
          ss_VALIDATE_MEMORY(rts,methods3);

13648
          ssSetModelMethods3(childS, methods3);

13649
        }

13650


13651
        /* Allocate memory for states auxilliary information */

13652
        {

13653
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

13654
            (sizeof(struct _ssStatesInfo2));

13655
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

13656
            malloc(sizeof(ssPeriodicStatesInfo));

13657
          ss_VALIDATE_MEMORY(rts,statesInfo2);

13658
          ssSetStatesInfo2(childS, statesInfo2);

13659
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

13660
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

13661
        }

13662


13663
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

13664
          RegNumInputPorts);

13665
        ssSetRegNumInputPortsFcnArg(childS,childS);

13666


13667
        /* inputs */

13668
        {

13669
          struct _ssPortInputs *inputPortInfo =

13670
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

13671
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

13672
          _ssSetNumInputPorts(childS, 6);

13673
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

13674


13675
          /* port 0 */

13676
          {

13677
            real32_T const **sfcnUPtrs = (real32_T const **)

13678
              malloc(1 * sizeof(real32_T *));

13679
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13680
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13681
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

13682
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

13683
            _ssSetInputPortNumDimensions(childS, 0, 1);

13684
            ssSetInputPortWidth(childS, 0, 1);

13685
          }

13686


13687
          /* port 1 */

13688
          {

13689
            int8_T const **sfcnUPtrs = (int8_T const **)

13690
              malloc(1 * sizeof(int8_T *));

13691
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13692
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

13693
              ssGetLocalBlockIO(rts))->DataTypeConversion5_n;

13694
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

13695
            _ssSetInputPortNumDimensions(childS, 1, 1);

13696
            ssSetInputPortWidth(childS, 1, 1);

13697
          }

13698


13699
          /* port 2 */

13700
          {

13701
            real32_T const **sfcnUPtrs = (real32_T const **)

13702
              malloc(1 * sizeof(real32_T *));

13703
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13704
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

13705
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

13706
            _ssSetInputPortNumDimensions(childS, 2, 1);

13707
            ssSetInputPortWidth(childS, 2, 1);

13708
          }

13709


13710
          /* port 3 */

13711
          {

13712
            real32_T const **sfcnUPtrs = (real32_T const **)

13713
              malloc(1 * sizeof(real32_T *));

13714
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13715
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13716
              ssGetLocalBlockIO(rts))->Switch_bg;

13717
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

13718
            _ssSetInputPortNumDimensions(childS, 3, 1);

13719
            ssSetInputPortWidth(childS, 3, 1);

13720
          }

13721


13722
          /* port 4 */

13723
          {

13724
            real32_T const **sfcnUPtrs = (real32_T const **)

13725
              malloc(1 * sizeof(real32_T *));

13726
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13727
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13728
              ssGetLocalBlockIO(rts))->Switch_bg;

13729
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

13730
            _ssSetInputPortNumDimensions(childS, 4, 1);

13731
            ssSetInputPortWidth(childS, 4, 1);

13732
          }

13733


13734
          /* port 5 */

13735
          {

13736
            real32_T const **sfcnUPtrs = (real32_T const **)

13737
              malloc(1 * sizeof(real32_T *));

13738
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13739
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

13740
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

13741
            _ssSetInputPortNumDimensions(childS, 5, 1);

13742
            ssSetInputPortWidth(childS, 5, 1);

13743
          }

13744
        }

13745


13746
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

13747
          RegNumOutputPorts);

13748
        ssSetRegNumOutputPortsFcnArg(childS,childS);

13749


13750
        /* outputs */

13751
        {

13752
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

13753
            calloc(1, sizeof(struct _ssPortOutputs));

13754
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

13755
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

13756
          _ssSetNumOutputPorts(childS, 1);

13757


13758
          /* port 0 */

13759
          {

13760
            _ssSetOutputPortNumDimensions(childS, 0, 1);

13761
            ssSetOutputPortWidth(childS, 0, 1);

13762
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

13763
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_b));

13764
          }

13765
        }

13766


13767
        /* path info */

13768
        _ssSetModelName(childS, "LagFilter_sf");

13769
        _ssSetPath(childS,

13770
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PLControl/ lag filter/Generated S-Function4");

13771
        if (ssGetRTModel(rts) == (NULL)) {

13772
          _ssSetParentSS(childS, rts);

13773
          _ssSetRootSS(childS, ssGetRootSS(rts));

13774
        } else {

13775
          ssSetRTModel(childS,ssGetRTModel(rts));

13776
          _ssSetParentSS(childS, (NULL));

13777
          _ssSetRootSS(childS, childS);

13778
        }

13779


13780
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

13781


13782
        /* work vectors */

13783
        {

13784
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

13785
            (4 * sizeof(struct _ssDWorkRecord));

13786
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

13787
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

13788
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

13789
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

13790
          ssSetSFcnDWork(childS, dWorkRecord);

13791
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

13792
          _ssSetNumDWork(childS, 4);

13793


13794
          /* DWORK0 */

13795
          ssSetDWorkWidth(childS, 0, 1);

13796
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

13797
          ssSetDWorkComplexSignal(childS, 0, 0);

13798
          ssSetDWorkUsedAsDState(childS, 0, 1);

13799
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 189))[0]);

13800


13801
          /* DWORK1 */

13802
          ssSetDWorkWidth(childS, 1, 1);

13803
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

13804
          ssSetDWorkComplexSignal(childS, 1, 0);

13805
          ssSetDWorkUsedAsDState(childS, 1, 1);

13806
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 190))[0]);

13807


13808
          /* DWORK2 */

13809
          ssSetDWorkWidth(childS, 2, 1);

13810
          ssSetDWorkDataType(childS, 2,SS_INT8);

13811
          ssSetDWorkComplexSignal(childS, 2, 0);

13812
          ssSetDWorkUsedAsDState(childS, 2, 1);

13813
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 417))[0]);

13814


13815
          /* DWORK3 */

13816
          ssSetDWorkWidth(childS, 3, 1);

13817
          ssSetDWorkDataType(childS, 3,SS_INT8);

13818
          ssSetDWorkComplexSignal(childS, 3, 0);

13819
          ssSetDWorkUsedAsDState(childS, 3, 1);

13820
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 418))[0]);

13821
        }

13822


13823
        (childS)->regDataType.arg1 = ((void *)(childS));

13824
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

13825
          FcnSetErrorStatus);

13826
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

13827
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

13828
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

13829
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

13830


13831
        /* registration */

13832
#if defined(MATLAB_MEX_FILE)

13833


13834
        {

13835
          int_T i;

13836
          mxArray *plhs[1];

13837
          mxArray *prhs[4];

13838
          double *pr;

13839
          volatile int_T *intS = (int_T *)&childS;

13840
          int_T addrlen = sizeof(SimStruct *);

13841
          int_T m = addrlen/sizeof(int_T) + 1;

13842
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

13843
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

13844
          pr = mxGetPr(prhs[1]);

13845
          for (i = 0; i < m - 1; i++) {

13846
            pr[i] = (double)intS[i];

13847
          }

13848


13849
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

13850
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

13851
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

13852


13853
          /* Reset port dimensions info functions because the S-function

13854
           * and accelerator mex-files explicitly set their dimensions,

13855
           * i.e., they are not dynamically sized. For this case, the

13856
           * mex-file is responsible for the dimensions info memory

13857
           * and Simulink should not free it. This is achieved by

13858
           * setting the following two methods to NULL.

13859
           */

13860
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

13861
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

13862


13863
          /*

13864
           * Setup function pointers and call mdlInitializeSizes via

13865
           * simulink.c

13866
           */

13867
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

13868
          mxDestroyArray(plhs[0]);

13869
          mxDestroyArray(prhs[0]);

13870
          mxDestroyArray(prhs[1]);

13871
          mxDestroyArray(prhs[2]);

13872
          mxDestroyArray(prhs[3]);

13873
        }

13874


13875
#else

13876


13877
        {

13878
          LagFilter_sf(childS);

13879
          sfcnInitializeSizes(childS);

13880
        }

13881


13882
#endif

13883


13884
        sfcnInitializeSampleTimes(childS);

13885


13886
        /* adjust sample time */

13887
        ssSetSampleTime(childS, 0, 0.0);

13888
        ssSetOffsetTime(childS, 0, 0.0);

13889
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

13890


13891
        /* set compiled values of dynamic vector attributes */

13892
        ssSetNumNonsampledZCs(childS, 0);

13893


13894
        /* Update connectivity flags for each port */

13895
        _ssSetInputPortConnected(childS, 0, 1);

13896
        _ssSetInputPortConnected(childS, 1, 1);

13897
        _ssSetInputPortConnected(childS, 2, 1);

13898
        _ssSetInputPortConnected(childS, 3, 1);

13899
        _ssSetInputPortConnected(childS, 4, 1);

13900
        _ssSetInputPortConnected(childS, 5, 1);

13901
        _ssSetOutputPortConnected(childS, 0, 1);

13902
        _ssSetOutputPortBeingMerged(childS, 0, 0);

13903


13904
        /* Update the BufferDstPort flags for each input port */

13905
        _ssSetInputPortBufferDstPort(childS, 0, -1);

13906
        _ssSetInputPortBufferDstPort(childS, 1, -1);

13907
        _ssSetInputPortBufferDstPort(childS, 2, -1);

13908
        _ssSetInputPortBufferDstPort(childS, 3, -1);

13909
        _ssSetInputPortBufferDstPort(childS, 4, -1);

13910
        _ssSetInputPortBufferDstPort(childS, 5, -1);

13911
      }

13912


13913
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S125>/Generated S-Function6 (Res180_sf) */

13914
      {

13915
        SimStruct *childS = ssGetSFunction(rts, 51);

13916


13917
        /* timing info */

13918
        time_T *sfcnPeriod;

13919
        time_T *sfcnOffset;

13920
        int_T *sfcnTsMap;

13921
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

13922
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

13923
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

13924
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

13925
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

13926
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

13927
        (void) memset((void*)sfcnPeriod, 0,

13928
                      sizeof(time_T)*1);

13929
        (void) memset((void*)sfcnOffset, 0,

13930
                      sizeof(time_T)*1);

13931
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

13932
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

13933
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

13934


13935
        /* Set up the mdlInfo pointer */

13936
# ifdef USE_RTMODEL

13937


13938
        {

13939
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

13940
              struct _ssBlkInfo2));

13941
          ss_VALIDATE_MEMORY(rts,blkInfo2);

13942
          ssSetBlkInfo2Ptr(childS, blkInfo2);

13943
        }

13944


13945
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

13946


13947
# else

13948


13949
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

13950


13951
# endif                                /* USE_RTMODEL */

13952


13953
        /* Allocate memory of model methods 2 */

13954
        {

13955
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

13956
            malloc(sizeof(struct _ssSFcnModelMethods2));

13957
          ss_VALIDATE_MEMORY(rts,methods2);

13958
          ssSetModelMethods2(childS, methods2);

13959
        }

13960


13961
        /* Allocate memory of model methods 3 */

13962
        {

13963
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

13964
            malloc(sizeof(struct _ssSFcnModelMethods3));

13965
          ss_VALIDATE_MEMORY(rts,methods3);

13966
          ssSetModelMethods3(childS, methods3);

13967
        }

13968


13969
        /* Allocate memory for states auxilliary information */

13970
        {

13971
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

13972
            (sizeof(struct _ssStatesInfo2));

13973
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

13974
            malloc(sizeof(ssPeriodicStatesInfo));

13975
          ss_VALIDATE_MEMORY(rts,statesInfo2);

13976
          ssSetStatesInfo2(childS, statesInfo2);

13977
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

13978
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

13979
        }

13980


13981
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

13982
          RegNumInputPorts);

13983
        ssSetRegNumInputPortsFcnArg(childS,childS);

13984


13985
        /* inputs */

13986
        {

13987
          struct _ssPortInputs *inputPortInfo =

13988
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

13989
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

13990
          _ssSetNumInputPorts(childS, 1);

13991
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

13992


13993
          /* port 0 */

13994
          {

13995
            real32_T const **sfcnUPtrs = (real32_T const **)

13996
              malloc(1 * sizeof(real32_T *));

13997
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

13998
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

13999
              ssGetLocalBlockIO(rts))->Sum1_lf;

14000
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

14001
            _ssSetInputPortNumDimensions(childS, 0, 1);

14002
            ssSetInputPortWidth(childS, 0, 1);

14003
          }

14004
        }

14005


14006
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

14007
          RegNumOutputPorts);

14008
        ssSetRegNumOutputPortsFcnArg(childS,childS);

14009


14010
        /* outputs */

14011
        {

14012
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

14013
            calloc(1, sizeof(struct _ssPortOutputs));

14014
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

14015
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

14016
          _ssSetNumOutputPorts(childS, 1);

14017


14018
          /* port 0 */

14019
          {

14020
            _ssSetOutputPortNumDimensions(childS, 0, 1);

14021
            ssSetOutputPortWidth(childS, 0, 1);

14022
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

14023
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_h));

14024
          }

14025
        }

14026


14027
        /* path info */

14028
        _ssSetModelName(childS, "Res180_sf");

14029
        _ssSetPath(childS,

14030
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Generated S-Function6");

14031
        if (ssGetRTModel(rts) == (NULL)) {

14032
          _ssSetParentSS(childS, rts);

14033
          _ssSetRootSS(childS, ssGetRootSS(rts));

14034
        } else {

14035
          ssSetRTModel(childS,ssGetRTModel(rts));

14036
          _ssSetParentSS(childS, (NULL));

14037
          _ssSetRootSS(childS, childS);

14038
        }

14039


14040
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

14041
        (childS)->regDataType.arg1 = ((void *)(childS));

14042
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

14043
          FcnSetErrorStatus);

14044
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

14045
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

14046
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

14047
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

14048


14049
        /* registration */

14050
#if defined(MATLAB_MEX_FILE)

14051


14052
        {

14053
          int_T i;

14054
          mxArray *plhs[1];

14055
          mxArray *prhs[4];

14056
          double *pr;

14057
          volatile int_T *intS = (int_T *)&childS;

14058
          int_T addrlen = sizeof(SimStruct *);

14059
          int_T m = addrlen/sizeof(int_T) + 1;

14060
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

14061
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

14062
          pr = mxGetPr(prhs[1]);

14063
          for (i = 0; i < m - 1; i++) {

14064
            pr[i] = (double)intS[i];

14065
          }

14066


14067
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

14068
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

14069
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

14070


14071
          /* Reset port dimensions info functions because the S-function

14072
           * and accelerator mex-files explicitly set their dimensions,

14073
           * i.e., they are not dynamically sized. For this case, the

14074
           * mex-file is responsible for the dimensions info memory

14075
           * and Simulink should not free it. This is achieved by

14076
           * setting the following two methods to NULL.

14077
           */

14078
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

14079
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

14080


14081
          /*

14082
           * Setup function pointers and call mdlInitializeSizes via

14083
           * simulink.c

14084
           */

14085
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

14086
          mxDestroyArray(plhs[0]);

14087
          mxDestroyArray(prhs[0]);

14088
          mxDestroyArray(prhs[1]);

14089
          mxDestroyArray(prhs[2]);

14090
          mxDestroyArray(prhs[3]);

14091
        }

14092


14093
#else

14094


14095
        {

14096
          Res180_sf(childS);

14097
          sfcnInitializeSizes(childS);

14098
        }

14099


14100
#endif

14101


14102
        sfcnInitializeSampleTimes(childS);

14103


14104
        /* adjust sample time */

14105
        ssSetSampleTime(childS, 0, 0.0);

14106
        ssSetOffsetTime(childS, 0, 0.0);

14107
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

14108


14109
        /* set compiled values of dynamic vector attributes */

14110
        ssSetNumNonsampledZCs(childS, 0);

14111


14112
        /* Update connectivity flags for each port */

14113
        _ssSetInputPortConnected(childS, 0, 1);

14114
        _ssSetOutputPortConnected(childS, 0, 1);

14115
        _ssSetOutputPortBeingMerged(childS, 0, 0);

14116


14117
        /* Update the BufferDstPort flags for each input port */

14118
        _ssSetInputPortBufferDstPort(childS, 0, -1);

14119
      }

14120


14121
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S134>/Generated S-Function1 (SaturationLimiter_sf) */

14122
      {

14123
        SimStruct *childS = ssGetSFunction(rts, 52);

14124


14125
        /* timing info */

14126
        time_T *sfcnPeriod;

14127
        time_T *sfcnOffset;

14128
        int_T *sfcnTsMap;

14129
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

14130
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

14131
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

14132
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

14133
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

14134
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

14135
        (void) memset((void*)sfcnPeriod, 0,

14136
                      sizeof(time_T)*1);

14137
        (void) memset((void*)sfcnOffset, 0,

14138
                      sizeof(time_T)*1);

14139
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

14140
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

14141
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

14142


14143
        /* Set up the mdlInfo pointer */

14144
# ifdef USE_RTMODEL

14145


14146
        {

14147
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

14148
              struct _ssBlkInfo2));

14149
          ss_VALIDATE_MEMORY(rts,blkInfo2);

14150
          ssSetBlkInfo2Ptr(childS, blkInfo2);

14151
        }

14152


14153
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

14154


14155
# else

14156


14157
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

14158


14159
# endif                                /* USE_RTMODEL */

14160


14161
        /* Allocate memory of model methods 2 */

14162
        {

14163
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

14164
            malloc(sizeof(struct _ssSFcnModelMethods2));

14165
          ss_VALIDATE_MEMORY(rts,methods2);

14166
          ssSetModelMethods2(childS, methods2);

14167
        }

14168


14169
        /* Allocate memory of model methods 3 */

14170
        {

14171
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

14172
            malloc(sizeof(struct _ssSFcnModelMethods3));

14173
          ss_VALIDATE_MEMORY(rts,methods3);

14174
          ssSetModelMethods3(childS, methods3);

14175
        }

14176


14177
        /* Allocate memory for states auxilliary information */

14178
        {

14179
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

14180
            (sizeof(struct _ssStatesInfo2));

14181
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

14182
            malloc(sizeof(ssPeriodicStatesInfo));

14183
          ss_VALIDATE_MEMORY(rts,statesInfo2);

14184
          ssSetStatesInfo2(childS, statesInfo2);

14185
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

14186
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

14187
        }

14188


14189
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

14190
          RegNumInputPorts);

14191
        ssSetRegNumInputPortsFcnArg(childS,childS);

14192


14193
        /* inputs */

14194
        {

14195
          struct _ssPortInputs *inputPortInfo =

14196
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

14197
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

14198
          _ssSetNumInputPorts(childS, 3);

14199
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

14200


14201
          /* port 0 */

14202
          {

14203
            real32_T const **sfcnUPtrs = (real32_T const **)

14204
              malloc(1 * sizeof(real32_T *));

14205
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14206
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

14207
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_h;

14208
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

14209
            _ssSetInputPortNumDimensions(childS, 0, 1);

14210
            ssSetInputPortWidth(childS, 0, 1);

14211
          }

14212


14213
          /* port 1 */

14214
          {

14215
            real32_T const **sfcnUPtrs = (real32_T const **)

14216
              malloc(1 * sizeof(real32_T *));

14217
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14218
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

14219
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

14220
            _ssSetInputPortNumDimensions(childS, 1, 1);

14221
            ssSetInputPortWidth(childS, 1, 1);

14222
          }

14223


14224
          /* port 2 */

14225
          {

14226
            real32_T const **sfcnUPtrs = (real32_T const **)

14227
              malloc(1 * sizeof(real32_T *));

14228
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14229
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

14230
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

14231
            _ssSetInputPortNumDimensions(childS, 2, 1);

14232
            ssSetInputPortWidth(childS, 2, 1);

14233
          }

14234
        }

14235


14236
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

14237
          RegNumOutputPorts);

14238
        ssSetRegNumOutputPortsFcnArg(childS,childS);

14239


14240
        /* outputs */

14241
        {

14242
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

14243
            calloc(1, sizeof(struct _ssPortOutputs));

14244
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

14245
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

14246
          _ssSetNumOutputPorts(childS, 1);

14247


14248
          /* port 0 */

14249
          {

14250
            _ssSetOutputPortNumDimensions(childS, 0, 1);

14251
            ssSetOutputPortWidth(childS, 0, 1);

14252
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

14253
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_c));

14254
          }

14255
        }

14256


14257
        /* path info */

14258
        _ssSetModelName(childS, "SaturationLimiter_sf");

14259
        _ssSetPath(childS,

14260
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Saturation Limiter/Generated S-Function1");

14261
        if (ssGetRTModel(rts) == (NULL)) {

14262
          _ssSetParentSS(childS, rts);

14263
          _ssSetRootSS(childS, ssGetRootSS(rts));

14264
        } else {

14265
          ssSetRTModel(childS,ssGetRTModel(rts));

14266
          _ssSetParentSS(childS, (NULL));

14267
          _ssSetRootSS(childS, childS);

14268
        }

14269


14270
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

14271
        (childS)->regDataType.arg1 = ((void *)(childS));

14272
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

14273
          FcnSetErrorStatus);

14274
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

14275
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

14276
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

14277
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

14278


14279
        /* registration */

14280
#if defined(MATLAB_MEX_FILE)

14281


14282
        {

14283
          int_T i;

14284
          mxArray *plhs[1];

14285
          mxArray *prhs[4];

14286
          double *pr;

14287
          volatile int_T *intS = (int_T *)&childS;

14288
          int_T addrlen = sizeof(SimStruct *);

14289
          int_T m = addrlen/sizeof(int_T) + 1;

14290
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

14291
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

14292
          pr = mxGetPr(prhs[1]);

14293
          for (i = 0; i < m - 1; i++) {

14294
            pr[i] = (double)intS[i];

14295
          }

14296


14297
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

14298
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

14299
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

14300


14301
          /* Reset port dimensions info functions because the S-function

14302
           * and accelerator mex-files explicitly set their dimensions,

14303
           * i.e., they are not dynamically sized. For this case, the

14304
           * mex-file is responsible for the dimensions info memory

14305
           * and Simulink should not free it. This is achieved by

14306
           * setting the following two methods to NULL.

14307
           */

14308
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

14309
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

14310


14311
          /*

14312
           * Setup function pointers and call mdlInitializeSizes via

14313
           * simulink.c

14314
           */

14315
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

14316
          mxDestroyArray(plhs[0]);

14317
          mxDestroyArray(prhs[0]);

14318
          mxDestroyArray(prhs[1]);

14319
          mxDestroyArray(prhs[2]);

14320
          mxDestroyArray(prhs[3]);

14321
        }

14322


14323
#else

14324


14325
        {

14326
          SaturationLimiter_sf(childS);

14327
          sfcnInitializeSizes(childS);

14328
        }

14329


14330
#endif

14331


14332
        sfcnInitializeSampleTimes(childS);

14333


14334
        /* adjust sample time */

14335
        ssSetSampleTime(childS, 0, 0.0);

14336
        ssSetOffsetTime(childS, 0, 0.0);

14337
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

14338


14339
        /* set compiled values of dynamic vector attributes */

14340
        ssSetNumNonsampledZCs(childS, 0);

14341


14342
        /* Update connectivity flags for each port */

14343
        _ssSetInputPortConnected(childS, 0, 1);

14344
        _ssSetInputPortConnected(childS, 1, 1);

14345
        _ssSetInputPortConnected(childS, 2, 1);

14346
        _ssSetOutputPortConnected(childS, 0, 1);

14347
        _ssSetOutputPortBeingMerged(childS, 0, 0);

14348


14349
        /* Update the BufferDstPort flags for each input port */

14350
        _ssSetInputPortBufferDstPort(childS, 0, -1);

14351
        _ssSetInputPortBufferDstPort(childS, 1, -1);

14352
        _ssSetInputPortBufferDstPort(childS, 2, -1);

14353
      }

14354


14355
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S135>/Generated S-Function (Gain_sf) */

14356
      {

14357
        SimStruct *childS = ssGetSFunction(rts, 53);

14358


14359
        /* timing info */

14360
        time_T *sfcnPeriod;

14361
        time_T *sfcnOffset;

14362
        int_T *sfcnTsMap;

14363
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

14364
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

14365
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

14366
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

14367
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

14368
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

14369
        (void) memset((void*)sfcnPeriod, 0,

14370
                      sizeof(time_T)*1);

14371
        (void) memset((void*)sfcnOffset, 0,

14372
                      sizeof(time_T)*1);

14373
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

14374
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

14375
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

14376


14377
        /* Set up the mdlInfo pointer */

14378
# ifdef USE_RTMODEL

14379


14380
        {

14381
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

14382
              struct _ssBlkInfo2));

14383
          ss_VALIDATE_MEMORY(rts,blkInfo2);

14384
          ssSetBlkInfo2Ptr(childS, blkInfo2);

14385
        }

14386


14387
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

14388


14389
# else

14390


14391
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

14392


14393
# endif                                /* USE_RTMODEL */

14394


14395
        /* Allocate memory of model methods 2 */

14396
        {

14397
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

14398
            malloc(sizeof(struct _ssSFcnModelMethods2));

14399
          ss_VALIDATE_MEMORY(rts,methods2);

14400
          ssSetModelMethods2(childS, methods2);

14401
        }

14402


14403
        /* Allocate memory of model methods 3 */

14404
        {

14405
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

14406
            malloc(sizeof(struct _ssSFcnModelMethods3));

14407
          ss_VALIDATE_MEMORY(rts,methods3);

14408
          ssSetModelMethods3(childS, methods3);

14409
        }

14410


14411
        /* Allocate memory for states auxilliary information */

14412
        {

14413
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

14414
            (sizeof(struct _ssStatesInfo2));

14415
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

14416
            malloc(sizeof(ssPeriodicStatesInfo));

14417
          ss_VALIDATE_MEMORY(rts,statesInfo2);

14418
          ssSetStatesInfo2(childS, statesInfo2);

14419
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

14420
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

14421
        }

14422


14423
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

14424
          RegNumInputPorts);

14425
        ssSetRegNumInputPortsFcnArg(childS,childS);

14426


14427
        /* inputs */

14428
        {

14429
          struct _ssPortInputs *inputPortInfo =

14430
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

14431
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

14432
          _ssSetNumInputPorts(childS, 2);

14433
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

14434


14435
          /* port 0 */

14436
          {

14437
            real32_T const **sfcnUPtrs = (real32_T const **)

14438
              malloc(1 * sizeof(real32_T *));

14439
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14440
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

14441
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_c;

14442
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

14443
            _ssSetInputPortNumDimensions(childS, 0, 1);

14444
            ssSetInputPortWidth(childS, 0, 1);

14445
          }

14446


14447
          /* port 1 */

14448
          {

14449
            real32_T const **sfcnUPtrs = (real32_T const **)

14450
              malloc(1 * sizeof(real32_T *));

14451
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14452
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

14453
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

14454
            _ssSetInputPortNumDimensions(childS, 1, 1);

14455
            ssSetInputPortWidth(childS, 1, 1);

14456
          }

14457
        }

14458


14459
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

14460
          RegNumOutputPorts);

14461
        ssSetRegNumOutputPortsFcnArg(childS,childS);

14462


14463
        /* outputs */

14464
        {

14465
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

14466
            calloc(1, sizeof(struct _ssPortOutputs));

14467
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

14468
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

14469
          _ssSetNumOutputPorts(childS, 1);

14470


14471
          /* port 0 */

14472
          {

14473
            _ssSetOutputPortNumDimensions(childS, 0, 1);

14474
            ssSetOutputPortWidth(childS, 0, 1);

14475
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

14476
              ssGetLocalBlockIO(rts))->GeneratedSFunction_hw));

14477
          }

14478
        }

14479


14480
        /* path info */

14481
        _ssSetModelName(childS, "Gain_sf");

14482
        _ssSetPath(childS,

14483
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/gain/Generated S-Function");

14484
        if (ssGetRTModel(rts) == (NULL)) {

14485
          _ssSetParentSS(childS, rts);

14486
          _ssSetRootSS(childS, ssGetRootSS(rts));

14487
        } else {

14488
          ssSetRTModel(childS,ssGetRTModel(rts));

14489
          _ssSetParentSS(childS, (NULL));

14490
          _ssSetRootSS(childS, childS);

14491
        }

14492


14493
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

14494
        (childS)->regDataType.arg1 = ((void *)(childS));

14495
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

14496
          FcnSetErrorStatus);

14497
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

14498
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

14499
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

14500
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

14501


14502
        /* registration */

14503
#if defined(MATLAB_MEX_FILE)

14504


14505
        {

14506
          int_T i;

14507
          mxArray *plhs[1];

14508
          mxArray *prhs[4];

14509
          double *pr;

14510
          volatile int_T *intS = (int_T *)&childS;

14511
          int_T addrlen = sizeof(SimStruct *);

14512
          int_T m = addrlen/sizeof(int_T) + 1;

14513
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

14514
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

14515
          pr = mxGetPr(prhs[1]);

14516
          for (i = 0; i < m - 1; i++) {

14517
            pr[i] = (double)intS[i];

14518
          }

14519


14520
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

14521
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

14522
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

14523


14524
          /* Reset port dimensions info functions because the S-function

14525
           * and accelerator mex-files explicitly set their dimensions,

14526
           * i.e., they are not dynamically sized. For this case, the

14527
           * mex-file is responsible for the dimensions info memory

14528
           * and Simulink should not free it. This is achieved by

14529
           * setting the following two methods to NULL.

14530
           */

14531
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

14532
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

14533


14534
          /*

14535
           * Setup function pointers and call mdlInitializeSizes via

14536
           * simulink.c

14537
           */

14538
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

14539
          mxDestroyArray(plhs[0]);

14540
          mxDestroyArray(prhs[0]);

14541
          mxDestroyArray(prhs[1]);

14542
          mxDestroyArray(prhs[2]);

14543
          mxDestroyArray(prhs[3]);

14544
        }

14545


14546
#else

14547


14548
        {

14549
          Gain_sf(childS);

14550
          sfcnInitializeSizes(childS);

14551
        }

14552


14553
#endif

14554


14555
        sfcnInitializeSampleTimes(childS);

14556


14557
        /* adjust sample time */

14558
        ssSetSampleTime(childS, 0, 0.0);

14559
        ssSetOffsetTime(childS, 0, 0.0);

14560
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

14561


14562
        /* set compiled values of dynamic vector attributes */

14563
        ssSetNumNonsampledZCs(childS, 0);

14564


14565
        /* Update connectivity flags for each port */

14566
        _ssSetInputPortConnected(childS, 0, 1);

14567
        _ssSetInputPortConnected(childS, 1, 1);

14568
        _ssSetOutputPortConnected(childS, 0, 1);

14569
        _ssSetOutputPortBeingMerged(childS, 0, 0);

14570


14571
        /* Update the BufferDstPort flags for each input port */

14572
        _ssSetInputPortBufferDstPort(childS, 0, -1);

14573
        _ssSetInputPortBufferDstPort(childS, 1, -1);

14574
      }

14575


14576
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S136>/Generated S-Function (Gain_sf) */

14577
      {

14578
        SimStruct *childS = ssGetSFunction(rts, 54);

14579


14580
        /* timing info */

14581
        time_T *sfcnPeriod;

14582
        time_T *sfcnOffset;

14583
        int_T *sfcnTsMap;

14584
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

14585
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

14586
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

14587
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

14588
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

14589
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

14590
        (void) memset((void*)sfcnPeriod, 0,

14591
                      sizeof(time_T)*1);

14592
        (void) memset((void*)sfcnOffset, 0,

14593
                      sizeof(time_T)*1);

14594
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

14595
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

14596
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

14597


14598
        /* Set up the mdlInfo pointer */

14599
# ifdef USE_RTMODEL

14600


14601
        {

14602
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

14603
              struct _ssBlkInfo2));

14604
          ss_VALIDATE_MEMORY(rts,blkInfo2);

14605
          ssSetBlkInfo2Ptr(childS, blkInfo2);

14606
        }

14607


14608
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

14609


14610
# else

14611


14612
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

14613


14614
# endif                                /* USE_RTMODEL */

14615


14616
        /* Allocate memory of model methods 2 */

14617
        {

14618
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

14619
            malloc(sizeof(struct _ssSFcnModelMethods2));

14620
          ss_VALIDATE_MEMORY(rts,methods2);

14621
          ssSetModelMethods2(childS, methods2);

14622
        }

14623


14624
        /* Allocate memory of model methods 3 */

14625
        {

14626
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

14627
            malloc(sizeof(struct _ssSFcnModelMethods3));

14628
          ss_VALIDATE_MEMORY(rts,methods3);

14629
          ssSetModelMethods3(childS, methods3);

14630
        }

14631


14632
        /* Allocate memory for states auxilliary information */

14633
        {

14634
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

14635
            (sizeof(struct _ssStatesInfo2));

14636
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

14637
            malloc(sizeof(ssPeriodicStatesInfo));

14638
          ss_VALIDATE_MEMORY(rts,statesInfo2);

14639
          ssSetStatesInfo2(childS, statesInfo2);

14640
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

14641
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

14642
        }

14643


14644
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

14645
          RegNumInputPorts);

14646
        ssSetRegNumInputPortsFcnArg(childS,childS);

14647


14648
        /* inputs */

14649
        {

14650
          struct _ssPortInputs *inputPortInfo =

14651
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

14652
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

14653
          _ssSetNumInputPorts(childS, 2);

14654
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

14655


14656
          /* port 0 */

14657
          {

14658
            real32_T const **sfcnUPtrs = (real32_T const **)

14659
              malloc(1 * sizeof(real32_T *));

14660
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14661
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

14662
              ssGetLocalBlockIO(rts))->GeneratedSFunction_hw;

14663
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

14664
            _ssSetInputPortNumDimensions(childS, 0, 1);

14665
            ssSetInputPortWidth(childS, 0, 1);

14666
          }

14667


14668
          /* port 1 */

14669
          {

14670
            real32_T const **sfcnUPtrs = (real32_T const **)

14671
              malloc(1 * sizeof(real32_T *));

14672
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14673
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

14674
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

14675
            _ssSetInputPortNumDimensions(childS, 1, 1);

14676
            ssSetInputPortWidth(childS, 1, 1);

14677
          }

14678
        }

14679


14680
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

14681
          RegNumOutputPorts);

14682
        ssSetRegNumOutputPortsFcnArg(childS,childS);

14683


14684
        /* outputs */

14685
        {

14686
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

14687
            calloc(1, sizeof(struct _ssPortOutputs));

14688
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

14689
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

14690
          _ssSetNumOutputPorts(childS, 1);

14691


14692
          /* port 0 */

14693
          {

14694
            _ssSetOutputPortNumDimensions(childS, 0, 1);

14695
            ssSetOutputPortWidth(childS, 0, 1);

14696
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

14697
              ssGetLocalBlockIO(rts))->MinMax));

14698
          }

14699
        }

14700


14701
        /* path info */

14702
        _ssSetModelName(childS, "Gain_sf");

14703
        _ssSetPath(childS,

14704
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/gain1/Generated S-Function");

14705
        if (ssGetRTModel(rts) == (NULL)) {

14706
          _ssSetParentSS(childS, rts);

14707
          _ssSetRootSS(childS, ssGetRootSS(rts));

14708
        } else {

14709
          ssSetRTModel(childS,ssGetRTModel(rts));

14710
          _ssSetParentSS(childS, (NULL));

14711
          _ssSetRootSS(childS, childS);

14712
        }

14713


14714
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

14715
        (childS)->regDataType.arg1 = ((void *)(childS));

14716
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

14717
          FcnSetErrorStatus);

14718
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

14719
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

14720
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

14721
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

14722


14723
        /* registration */

14724
#if defined(MATLAB_MEX_FILE)

14725


14726
        {

14727
          int_T i;

14728
          mxArray *plhs[1];

14729
          mxArray *prhs[4];

14730
          double *pr;

14731
          volatile int_T *intS = (int_T *)&childS;

14732
          int_T addrlen = sizeof(SimStruct *);

14733
          int_T m = addrlen/sizeof(int_T) + 1;

14734
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

14735
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

14736
          pr = mxGetPr(prhs[1]);

14737
          for (i = 0; i < m - 1; i++) {

14738
            pr[i] = (double)intS[i];

14739
          }

14740


14741
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

14742
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

14743
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

14744


14745
          /* Reset port dimensions info functions because the S-function

14746
           * and accelerator mex-files explicitly set their dimensions,

14747
           * i.e., they are not dynamically sized. For this case, the

14748
           * mex-file is responsible for the dimensions info memory

14749
           * and Simulink should not free it. This is achieved by

14750
           * setting the following two methods to NULL.

14751
           */

14752
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

14753
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

14754


14755
          /*

14756
           * Setup function pointers and call mdlInitializeSizes via

14757
           * simulink.c

14758
           */

14759
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

14760
          mxDestroyArray(plhs[0]);

14761
          mxDestroyArray(prhs[0]);

14762
          mxDestroyArray(prhs[1]);

14763
          mxDestroyArray(prhs[2]);

14764
          mxDestroyArray(prhs[3]);

14765
        }

14766


14767
#else

14768


14769
        {

14770
          Gain_sf(childS);

14771
          sfcnInitializeSizes(childS);

14772
        }

14773


14774
#endif

14775


14776
        sfcnInitializeSampleTimes(childS);

14777


14778
        /* adjust sample time */

14779
        ssSetSampleTime(childS, 0, 0.0);

14780
        ssSetOffsetTime(childS, 0, 0.0);

14781
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

14782


14783
        /* set compiled values of dynamic vector attributes */

14784
        ssSetNumNonsampledZCs(childS, 0);

14785


14786
        /* Update connectivity flags for each port */

14787
        _ssSetInputPortConnected(childS, 0, 1);

14788
        _ssSetInputPortConnected(childS, 1, 1);

14789
        _ssSetOutputPortConnected(childS, 0, 1);

14790
        _ssSetOutputPortBeingMerged(childS, 0, 0);

14791


14792
        /* Update the BufferDstPort flags for each input port */

14793
        _ssSetInputPortBufferDstPort(childS, 0, -1);

14794
        _ssSetInputPortBufferDstPort(childS, 1, -1);

14795
      }

14796


14797
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S137>/Generated S-Function (Gain_sf) */

14798
      {

14799
        SimStruct *childS = ssGetSFunction(rts, 55);

14800


14801
        /* timing info */

14802
        time_T *sfcnPeriod;

14803
        time_T *sfcnOffset;

14804
        int_T *sfcnTsMap;

14805
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

14806
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

14807
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

14808
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

14809
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

14810
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

14811
        (void) memset((void*)sfcnPeriod, 0,

14812
                      sizeof(time_T)*1);

14813
        (void) memset((void*)sfcnOffset, 0,

14814
                      sizeof(time_T)*1);

14815
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

14816
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

14817
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

14818


14819
        /* Set up the mdlInfo pointer */

14820
# ifdef USE_RTMODEL

14821


14822
        {

14823
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

14824
              struct _ssBlkInfo2));

14825
          ss_VALIDATE_MEMORY(rts,blkInfo2);

14826
          ssSetBlkInfo2Ptr(childS, blkInfo2);

14827
        }

14828


14829
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

14830


14831
# else

14832


14833
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

14834


14835
# endif                                /* USE_RTMODEL */

14836


14837
        /* Allocate memory of model methods 2 */

14838
        {

14839
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

14840
            malloc(sizeof(struct _ssSFcnModelMethods2));

14841
          ss_VALIDATE_MEMORY(rts,methods2);

14842
          ssSetModelMethods2(childS, methods2);

14843
        }

14844


14845
        /* Allocate memory of model methods 3 */

14846
        {

14847
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

14848
            malloc(sizeof(struct _ssSFcnModelMethods3));

14849
          ss_VALIDATE_MEMORY(rts,methods3);

14850
          ssSetModelMethods3(childS, methods3);

14851
        }

14852


14853
        /* Allocate memory for states auxilliary information */

14854
        {

14855
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

14856
            (sizeof(struct _ssStatesInfo2));

14857
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

14858
            malloc(sizeof(ssPeriodicStatesInfo));

14859
          ss_VALIDATE_MEMORY(rts,statesInfo2);

14860
          ssSetStatesInfo2(childS, statesInfo2);

14861
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

14862
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

14863
        }

14864


14865
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

14866
          RegNumInputPorts);

14867
        ssSetRegNumInputPortsFcnArg(childS,childS);

14868


14869
        /* inputs */

14870
        {

14871
          struct _ssPortInputs *inputPortInfo =

14872
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

14873
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

14874
          _ssSetNumInputPorts(childS, 2);

14875
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

14876


14877
          /* port 0 */

14878
          {

14879
            real32_T const **sfcnUPtrs = (real32_T const **)

14880
              malloc(1 * sizeof(real32_T *));

14881
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14882
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

14883
              ssGetLocalBlockIO(rts))->UnitDelay1_k;

14884
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

14885
            _ssSetInputPortNumDimensions(childS, 0, 1);

14886
            ssSetInputPortWidth(childS, 0, 1);

14887
          }

14888


14889
          /* port 1 */

14890
          {

14891
            real32_T const **sfcnUPtrs = (real32_T const **)

14892
              malloc(1 * sizeof(real32_T *));

14893
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

14894
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

14895
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

14896
            _ssSetInputPortNumDimensions(childS, 1, 1);

14897
            ssSetInputPortWidth(childS, 1, 1);

14898
          }

14899
        }

14900


14901
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

14902
          RegNumOutputPorts);

14903
        ssSetRegNumOutputPortsFcnArg(childS,childS);

14904


14905
        /* outputs */

14906
        {

14907
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

14908
            calloc(1, sizeof(struct _ssPortOutputs));

14909
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

14910
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

14911
          _ssSetNumOutputPorts(childS, 1);

14912


14913
          /* port 0 */

14914
          {

14915
            _ssSetOutputPortNumDimensions(childS, 0, 1);

14916
            ssSetOutputPortWidth(childS, 0, 1);

14917
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

14918
              ssGetLocalBlockIO(rts))->GeneratedSFunction_a));

14919
          }

14920
        }

14921


14922
        /* path info */

14923
        _ssSetModelName(childS, "Gain_sf");

14924
        _ssSetPath(childS,

14925
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/gain8/Generated S-Function");

14926
        if (ssGetRTModel(rts) == (NULL)) {

14927
          _ssSetParentSS(childS, rts);

14928
          _ssSetRootSS(childS, ssGetRootSS(rts));

14929
        } else {

14930
          ssSetRTModel(childS,ssGetRTModel(rts));

14931
          _ssSetParentSS(childS, (NULL));

14932
          _ssSetRootSS(childS, childS);

14933
        }

14934


14935
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

14936
        (childS)->regDataType.arg1 = ((void *)(childS));

14937
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

14938
          FcnSetErrorStatus);

14939
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

14940
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

14941
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

14942
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

14943


14944
        /* registration */

14945
#if defined(MATLAB_MEX_FILE)

14946


14947
        {

14948
          int_T i;

14949
          mxArray *plhs[1];

14950
          mxArray *prhs[4];

14951
          double *pr;

14952
          volatile int_T *intS = (int_T *)&childS;

14953
          int_T addrlen = sizeof(SimStruct *);

14954
          int_T m = addrlen/sizeof(int_T) + 1;

14955
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

14956
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

14957
          pr = mxGetPr(prhs[1]);

14958
          for (i = 0; i < m - 1; i++) {

14959
            pr[i] = (double)intS[i];

14960
          }

14961


14962
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

14963
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

14964
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

14965


14966
          /* Reset port dimensions info functions because the S-function

14967
           * and accelerator mex-files explicitly set their dimensions,

14968
           * i.e., they are not dynamically sized. For this case, the

14969
           * mex-file is responsible for the dimensions info memory

14970
           * and Simulink should not free it. This is achieved by

14971
           * setting the following two methods to NULL.

14972
           */

14973
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

14974
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

14975


14976
          /*

14977
           * Setup function pointers and call mdlInitializeSizes via

14978
           * simulink.c

14979
           */

14980
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

14981
          mxDestroyArray(plhs[0]);

14982
          mxDestroyArray(prhs[0]);

14983
          mxDestroyArray(prhs[1]);

14984
          mxDestroyArray(prhs[2]);

14985
          mxDestroyArray(prhs[3]);

14986
        }

14987


14988
#else

14989


14990
        {

14991
          Gain_sf(childS);

14992
          sfcnInitializeSizes(childS);

14993
        }

14994


14995
#endif

14996


14997
        sfcnInitializeSampleTimes(childS);

14998


14999
        /* adjust sample time */

15000
        ssSetSampleTime(childS, 0, 0.005);

15001
        ssSetOffsetTime(childS, 0, 0.0);

15002
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];

15003


15004
        /* set compiled values of dynamic vector attributes */

15005
        ssSetNumNonsampledZCs(childS, 0);

15006


15007
        /* Update connectivity flags for each port */

15008
        _ssSetInputPortConnected(childS, 0, 1);

15009
        _ssSetInputPortConnected(childS, 1, 1);

15010
        _ssSetOutputPortConnected(childS, 0, 1);

15011
        _ssSetOutputPortBeingMerged(childS, 0, 0);

15012


15013
        /* Update the BufferDstPort flags for each input port */

15014
        _ssSetInputPortBufferDstPort(childS, 0, -1);

15015
        _ssSetInputPortBufferDstPort(childS, 1, -1);

15016
      }

15017


15018
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S132>/Generated S-Function3 (IntegratorLimited_sf) */

15019
      {

15020
        SimStruct *childS = ssGetSFunction(rts, 56);

15021


15022
        /* timing info */

15023
        time_T *sfcnPeriod;

15024
        time_T *sfcnOffset;

15025
        int_T *sfcnTsMap;

15026
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

15027
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

15028
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

15029
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

15030
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

15031
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

15032
        (void) memset((void*)sfcnPeriod, 0,

15033
                      sizeof(time_T)*1);

15034
        (void) memset((void*)sfcnOffset, 0,

15035
                      sizeof(time_T)*1);

15036
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

15037
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

15038
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

15039


15040
        /* Set up the mdlInfo pointer */

15041
# ifdef USE_RTMODEL

15042


15043
        {

15044
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

15045
              struct _ssBlkInfo2));

15046
          ss_VALIDATE_MEMORY(rts,blkInfo2);

15047
          ssSetBlkInfo2Ptr(childS, blkInfo2);

15048
        }

15049


15050
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

15051


15052
# else

15053


15054
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

15055


15056
# endif                                /* USE_RTMODEL */

15057


15058
        /* Allocate memory of model methods 2 */

15059
        {

15060
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

15061
            malloc(sizeof(struct _ssSFcnModelMethods2));

15062
          ss_VALIDATE_MEMORY(rts,methods2);

15063
          ssSetModelMethods2(childS, methods2);

15064
        }

15065


15066
        /* Allocate memory of model methods 3 */

15067
        {

15068
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

15069
            malloc(sizeof(struct _ssSFcnModelMethods3));

15070
          ss_VALIDATE_MEMORY(rts,methods3);

15071
          ssSetModelMethods3(childS, methods3);

15072
        }

15073


15074
        /* Allocate memory for states auxilliary information */

15075
        {

15076
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

15077
            (sizeof(struct _ssStatesInfo2));

15078
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

15079
            malloc(sizeof(ssPeriodicStatesInfo));

15080
          ss_VALIDATE_MEMORY(rts,statesInfo2);

15081
          ssSetStatesInfo2(childS, statesInfo2);

15082
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

15083
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

15084
        }

15085


15086
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

15087
          RegNumInputPorts);

15088
        ssSetRegNumInputPortsFcnArg(childS,childS);

15089


15090
        /* inputs */

15091
        {

15092
          struct _ssPortInputs *inputPortInfo =

15093
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

15094
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

15095
          _ssSetNumInputPorts(childS, 7);

15096
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

15097


15098
          /* port 0 */

15099
          {

15100
            real32_T const **sfcnUPtrs = (real32_T const **)

15101
              malloc(1 * sizeof(real32_T *));

15102
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15103
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15104
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

15105
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

15106
            _ssSetInputPortNumDimensions(childS, 0, 1);

15107
            ssSetInputPortWidth(childS, 0, 1);

15108
          }

15109


15110
          /* port 1 */

15111
          {

15112
            int8_T const **sfcnUPtrs = (int8_T const **)

15113
              malloc(1 * sizeof(int8_T *));

15114
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15115
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

15116
              ssGetLocalBlockIO(rts))->DataTypeConversion3_d;

15117
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

15118
            _ssSetInputPortNumDimensions(childS, 1, 1);

15119
            ssSetInputPortWidth(childS, 1, 1);

15120
          }

15121


15122
          /* port 2 */

15123
          {

15124
            real32_T const **sfcnUPtrs = (real32_T const **)

15125
              malloc(1 * sizeof(real32_T *));

15126
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15127
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15128
              ssGetLocalBlockIO(rts))->Sum2_c;

15129
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

15130
            _ssSetInputPortNumDimensions(childS, 2, 1);

15131
            ssSetInputPortWidth(childS, 2, 1);

15132
          }

15133


15134
          /* port 3 */

15135
          {

15136
            real32_T const **sfcnUPtrs = (real32_T const **)

15137
              malloc(1 * sizeof(real32_T *));

15138
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15139
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15140
              ssGetLocalBlockIO(rts))->Sum2_c;

15141
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

15142
            _ssSetInputPortNumDimensions(childS, 3, 1);

15143
            ssSetInputPortWidth(childS, 3, 1);

15144
          }

15145


15146
          /* port 4 */

15147
          {

15148
            real32_T const **sfcnUPtrs = (real32_T const **)

15149
              malloc(1 * sizeof(real32_T *));

15150
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15151
            sfcnUPtrs[0] = (real32_T const *)

15152
              &AFCS_MODEL1_ConstP.Constant29_Value;

15153
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

15154
            _ssSetInputPortNumDimensions(childS, 4, 1);

15155
            ssSetInputPortWidth(childS, 4, 1);

15156
          }

15157


15158
          /* port 5 */

15159
          {

15160
            real32_T const **sfcnUPtrs = (real32_T const **)

15161
              malloc(1 * sizeof(real32_T *));

15162
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15163
            sfcnUPtrs[0] = (real32_T const *)

15164
              &AFCS_MODEL1_ConstP.Constant30_Value;

15165
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

15166
            _ssSetInputPortNumDimensions(childS, 5, 1);

15167
            ssSetInputPortWidth(childS, 5, 1);

15168
          }

15169


15170
          /* port 6 */

15171
          {

15172
            real32_T const **sfcnUPtrs = (real32_T const **)

15173
              malloc(1 * sizeof(real32_T *));

15174
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15175
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15176
              ssGetLocalBlockIO(rts))->Sum11;

15177
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

15178
            _ssSetInputPortNumDimensions(childS, 6, 1);

15179
            ssSetInputPortWidth(childS, 6, 1);

15180
          }

15181
        }

15182


15183
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

15184
          RegNumOutputPorts);

15185
        ssSetRegNumOutputPortsFcnArg(childS,childS);

15186


15187
        /* outputs */

15188
        {

15189
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

15190
            calloc(1, sizeof(struct _ssPortOutputs));

15191
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

15192
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

15193
          _ssSetNumOutputPorts(childS, 1);

15194


15195
          /* port 0 */

15196
          {

15197
            _ssSetOutputPortNumDimensions(childS, 0, 1);

15198
            ssSetOutputPortWidth(childS, 0, 1);

15199
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

15200
              ssGetLocalBlockIO(rts))->GeneratedSFunction3));

15201
          }

15202
        }

15203


15204
        /* path info */

15205
        _ssSetModelName(childS, "IntegratorLimited_sf");

15206
        _ssSetPath(childS,

15207
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Integrator Limited/Generated S-Function3");

15208
        if (ssGetRTModel(rts) == (NULL)) {

15209
          _ssSetParentSS(childS, rts);

15210
          _ssSetRootSS(childS, ssGetRootSS(rts));

15211
        } else {

15212
          ssSetRTModel(childS,ssGetRTModel(rts));

15213
          _ssSetParentSS(childS, (NULL));

15214
          _ssSetRootSS(childS, childS);

15215
        }

15216


15217
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

15218


15219
        /* work vectors */

15220
        {

15221
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

15222
            (4 * sizeof(struct _ssDWorkRecord));

15223
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

15224
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

15225
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

15226
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

15227
          ssSetSFcnDWork(childS, dWorkRecord);

15228
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

15229
          _ssSetNumDWork(childS, 4);

15230


15231
          /* DWORK0 */

15232
          ssSetDWorkWidth(childS, 0, 1);

15233
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

15234
          ssSetDWorkComplexSignal(childS, 0, 0);

15235
          ssSetDWorkUsedAsDState(childS, 0, 1);

15236
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 192))[0]);

15237


15238
          /* DWORK1 */

15239
          ssSetDWorkWidth(childS, 1, 1);

15240
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

15241
          ssSetDWorkComplexSignal(childS, 1, 0);

15242
          ssSetDWorkUsedAsDState(childS, 1, 1);

15243
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 193))[0]);

15244


15245
          /* DWORK2 */

15246
          ssSetDWorkWidth(childS, 2, 1);

15247
          ssSetDWorkDataType(childS, 2,SS_INT8);

15248
          ssSetDWorkComplexSignal(childS, 2, 0);

15249
          ssSetDWorkUsedAsDState(childS, 2, 1);

15250
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 419))[0]);

15251


15252
          /* DWORK3 */

15253
          ssSetDWorkWidth(childS, 3, 1);

15254
          ssSetDWorkDataType(childS, 3,SS_INT8);

15255
          ssSetDWorkComplexSignal(childS, 3, 0);

15256
          ssSetDWorkUsedAsDState(childS, 3, 1);

15257
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 420))[0]);

15258
        }

15259


15260
        (childS)->regDataType.arg1 = ((void *)(childS));

15261
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

15262
          FcnSetErrorStatus);

15263
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

15264
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

15265
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

15266
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

15267


15268
        /* registration */

15269
#if defined(MATLAB_MEX_FILE)

15270


15271
        {

15272
          int_T i;

15273
          mxArray *plhs[1];

15274
          mxArray *prhs[4];

15275
          double *pr;

15276
          volatile int_T *intS = (int_T *)&childS;

15277
          int_T addrlen = sizeof(SimStruct *);

15278
          int_T m = addrlen/sizeof(int_T) + 1;

15279
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

15280
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

15281
          pr = mxGetPr(prhs[1]);

15282
          for (i = 0; i < m - 1; i++) {

15283
            pr[i] = (double)intS[i];

15284
          }

15285


15286
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

15287
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

15288
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

15289


15290
          /* Reset port dimensions info functions because the S-function

15291
           * and accelerator mex-files explicitly set their dimensions,

15292
           * i.e., they are not dynamically sized. For this case, the

15293
           * mex-file is responsible for the dimensions info memory

15294
           * and Simulink should not free it. This is achieved by

15295
           * setting the following two methods to NULL.

15296
           */

15297
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

15298
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

15299


15300
          /*

15301
           * Setup function pointers and call mdlInitializeSizes via

15302
           * simulink.c

15303
           */

15304
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

15305
          mxDestroyArray(plhs[0]);

15306
          mxDestroyArray(prhs[0]);

15307
          mxDestroyArray(prhs[1]);

15308
          mxDestroyArray(prhs[2]);

15309
          mxDestroyArray(prhs[3]);

15310
        }

15311


15312
#else

15313


15314
        {

15315
          IntegratorLimited_sf(childS);

15316
          sfcnInitializeSizes(childS);

15317
        }

15318


15319
#endif

15320


15321
        sfcnInitializeSampleTimes(childS);

15322


15323
        /* adjust sample time */

15324
        ssSetSampleTime(childS, 0, 0.0);

15325
        ssSetOffsetTime(childS, 0, 0.0);

15326
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

15327


15328
        /* set compiled values of dynamic vector attributes */

15329
        ssSetNumNonsampledZCs(childS, 0);

15330


15331
        /* Update connectivity flags for each port */

15332
        _ssSetInputPortConnected(childS, 0, 1);

15333
        _ssSetInputPortConnected(childS, 1, 1);

15334
        _ssSetInputPortConnected(childS, 2, 1);

15335
        _ssSetInputPortConnected(childS, 3, 1);

15336
        _ssSetInputPortConnected(childS, 4, 1);

15337
        _ssSetInputPortConnected(childS, 5, 1);

15338
        _ssSetInputPortConnected(childS, 6, 1);

15339
        _ssSetOutputPortConnected(childS, 0, 1);

15340
        _ssSetOutputPortBeingMerged(childS, 0, 0);

15341


15342
        /* Update the BufferDstPort flags for each input port */

15343
        _ssSetInputPortBufferDstPort(childS, 0, -1);

15344
        _ssSetInputPortBufferDstPort(childS, 1, -1);

15345
        _ssSetInputPortBufferDstPort(childS, 2, -1);

15346
        _ssSetInputPortBufferDstPort(childS, 3, -1);

15347
        _ssSetInputPortBufferDstPort(childS, 4, -1);

15348
        _ssSetInputPortBufferDstPort(childS, 5, -1);

15349
        _ssSetInputPortBufferDstPort(childS, 6, -1);

15350
      }

15351


15352
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S133>/Generated S-Function2 (LeadLagFilter_sf) */

15353
      {

15354
        SimStruct *childS = ssGetSFunction(rts, 57);

15355


15356
        /* timing info */

15357
        time_T *sfcnPeriod;

15358
        time_T *sfcnOffset;

15359
        int_T *sfcnTsMap;

15360
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

15361
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

15362
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

15363
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

15364
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

15365
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

15366
        (void) memset((void*)sfcnPeriod, 0,

15367
                      sizeof(time_T)*1);

15368
        (void) memset((void*)sfcnOffset, 0,

15369
                      sizeof(time_T)*1);

15370
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

15371
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

15372
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

15373


15374
        /* Set up the mdlInfo pointer */

15375
# ifdef USE_RTMODEL

15376


15377
        {

15378
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

15379
              struct _ssBlkInfo2));

15380
          ss_VALIDATE_MEMORY(rts,blkInfo2);

15381
          ssSetBlkInfo2Ptr(childS, blkInfo2);

15382
        }

15383


15384
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

15385


15386
# else

15387


15388
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

15389


15390
# endif                                /* USE_RTMODEL */

15391


15392
        /* Allocate memory of model methods 2 */

15393
        {

15394
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

15395
            malloc(sizeof(struct _ssSFcnModelMethods2));

15396
          ss_VALIDATE_MEMORY(rts,methods2);

15397
          ssSetModelMethods2(childS, methods2);

15398
        }

15399


15400
        /* Allocate memory of model methods 3 */

15401
        {

15402
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

15403
            malloc(sizeof(struct _ssSFcnModelMethods3));

15404
          ss_VALIDATE_MEMORY(rts,methods3);

15405
          ssSetModelMethods3(childS, methods3);

15406
        }

15407


15408
        /* Allocate memory for states auxilliary information */

15409
        {

15410
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

15411
            (sizeof(struct _ssStatesInfo2));

15412
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

15413
            malloc(sizeof(ssPeriodicStatesInfo));

15414
          ss_VALIDATE_MEMORY(rts,statesInfo2);

15415
          ssSetStatesInfo2(childS, statesInfo2);

15416
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

15417
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

15418
        }

15419


15420
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

15421
          RegNumInputPorts);

15422
        ssSetRegNumInputPortsFcnArg(childS,childS);

15423


15424
        /* inputs */

15425
        {

15426
          struct _ssPortInputs *inputPortInfo =

15427
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

15428
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

15429
          _ssSetNumInputPorts(childS, 7);

15430
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

15431


15432
          /* port 0 */

15433
          {

15434
            real32_T const **sfcnUPtrs = (real32_T const **)

15435
              malloc(1 * sizeof(real32_T *));

15436
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15437
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15438
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

15439
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

15440
            _ssSetInputPortNumDimensions(childS, 0, 1);

15441
            ssSetInputPortWidth(childS, 0, 1);

15442
          }

15443


15444
          /* port 1 */

15445
          {

15446
            int8_T const **sfcnUPtrs = (int8_T const **)

15447
              malloc(1 * sizeof(int8_T *));

15448
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15449
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

15450
              ssGetLocalBlockIO(rts))->DataTypeConversion3_d;

15451
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

15452
            _ssSetInputPortNumDimensions(childS, 1, 1);

15453
            ssSetInputPortWidth(childS, 1, 1);

15454
          }

15455


15456
          /* port 2 */

15457
          {

15458
            real32_T const **sfcnUPtrs = (real32_T const **)

15459
              malloc(1 * sizeof(real32_T *));

15460
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15461
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

15462
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

15463
            _ssSetInputPortNumDimensions(childS, 2, 1);

15464
            ssSetInputPortWidth(childS, 2, 1);

15465
          }

15466


15467
          /* port 3 */

15468
          {

15469
            real32_T const **sfcnUPtrs = (real32_T const **)

15470
              malloc(1 * sizeof(real32_T *));

15471
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15472
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

15473
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

15474
            _ssSetInputPortNumDimensions(childS, 3, 1);

15475
            ssSetInputPortWidth(childS, 3, 1);

15476
          }

15477


15478
          /* port 4 */

15479
          {

15480
            real32_T const **sfcnUPtrs = (real32_T const **)

15481
              malloc(1 * sizeof(real32_T *));

15482
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15483
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15484
              ssGetLocalBlockIO(rts))->Switch_bg;

15485
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

15486
            _ssSetInputPortNumDimensions(childS, 4, 1);

15487
            ssSetInputPortWidth(childS, 4, 1);

15488
          }

15489


15490
          /* port 5 */

15491
          {

15492
            real32_T const **sfcnUPtrs = (real32_T const **)

15493
              malloc(1 * sizeof(real32_T *));

15494
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15495
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15496
              ssGetLocalBlockIO(rts))->Switch_bg;

15497
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

15498
            _ssSetInputPortNumDimensions(childS, 5, 1);

15499
            ssSetInputPortWidth(childS, 5, 1);

15500
          }

15501


15502
          /* port 6 */

15503
          {

15504
            real32_T const **sfcnUPtrs = (real32_T const **)

15505
              malloc(1 * sizeof(real32_T *));

15506
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15507
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15508
              ssGetLocalBlockIO(rts))->Sum_c;

15509
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

15510
            _ssSetInputPortNumDimensions(childS, 6, 1);

15511
            ssSetInputPortWidth(childS, 6, 1);

15512
          }

15513
        }

15514


15515
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

15516
          RegNumOutputPorts);

15517
        ssSetRegNumOutputPortsFcnArg(childS,childS);

15518


15519
        /* outputs */

15520
        {

15521
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

15522
            calloc(1, sizeof(struct _ssPortOutputs));

15523
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

15524
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

15525
          _ssSetNumOutputPorts(childS, 1);

15526


15527
          /* port 0 */

15528
          {

15529
            _ssSetOutputPortNumDimensions(childS, 0, 1);

15530
            ssSetOutputPortWidth(childS, 0, 1);

15531
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

15532
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_f));

15533
          }

15534
        }

15535


15536
        /* path info */

15537
        _ssSetModelName(childS, "LeadLagFilter_sf");

15538
        _ssSetPath(childS,

15539
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Lead lag/Generated S-Function2");

15540
        if (ssGetRTModel(rts) == (NULL)) {

15541
          _ssSetParentSS(childS, rts);

15542
          _ssSetRootSS(childS, ssGetRootSS(rts));

15543
        } else {

15544
          ssSetRTModel(childS,ssGetRTModel(rts));

15545
          _ssSetParentSS(childS, (NULL));

15546
          _ssSetRootSS(childS, childS);

15547
        }

15548


15549
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

15550


15551
        /* work vectors */

15552
        {

15553
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

15554
            (4 * sizeof(struct _ssDWorkRecord));

15555
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

15556
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

15557
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

15558
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

15559
          ssSetSFcnDWork(childS, dWorkRecord);

15560
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

15561
          _ssSetNumDWork(childS, 4);

15562


15563
          /* DWORK0 */

15564
          ssSetDWorkWidth(childS, 0, 1);

15565
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

15566
          ssSetDWorkComplexSignal(childS, 0, 0);

15567
          ssSetDWorkUsedAsDState(childS, 0, 1);

15568
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 194))[0]);

15569


15570
          /* DWORK1 */

15571
          ssSetDWorkWidth(childS, 1, 1);

15572
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

15573
          ssSetDWorkComplexSignal(childS, 1, 0);

15574
          ssSetDWorkUsedAsDState(childS, 1, 1);

15575
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 195))[0]);

15576


15577
          /* DWORK2 */

15578
          ssSetDWorkWidth(childS, 2, 1);

15579
          ssSetDWorkDataType(childS, 2,SS_INT8);

15580
          ssSetDWorkComplexSignal(childS, 2, 0);

15581
          ssSetDWorkUsedAsDState(childS, 2, 1);

15582
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 421))[0]);

15583


15584
          /* DWORK3 */

15585
          ssSetDWorkWidth(childS, 3, 1);

15586
          ssSetDWorkDataType(childS, 3,SS_INT8);

15587
          ssSetDWorkComplexSignal(childS, 3, 0);

15588
          ssSetDWorkUsedAsDState(childS, 3, 1);

15589
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 422))[0]);

15590
        }

15591


15592
        (childS)->regDataType.arg1 = ((void *)(childS));

15593
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

15594
          FcnSetErrorStatus);

15595
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

15596
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

15597
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

15598
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

15599


15600
        /* registration */

15601
#if defined(MATLAB_MEX_FILE)

15602


15603
        {

15604
          int_T i;

15605
          mxArray *plhs[1];

15606
          mxArray *prhs[4];

15607
          double *pr;

15608
          volatile int_T *intS = (int_T *)&childS;

15609
          int_T addrlen = sizeof(SimStruct *);

15610
          int_T m = addrlen/sizeof(int_T) + 1;

15611
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

15612
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

15613
          pr = mxGetPr(prhs[1]);

15614
          for (i = 0; i < m - 1; i++) {

15615
            pr[i] = (double)intS[i];

15616
          }

15617


15618
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

15619
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

15620
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

15621


15622
          /* Reset port dimensions info functions because the S-function

15623
           * and accelerator mex-files explicitly set their dimensions,

15624
           * i.e., they are not dynamically sized. For this case, the

15625
           * mex-file is responsible for the dimensions info memory

15626
           * and Simulink should not free it. This is achieved by

15627
           * setting the following two methods to NULL.

15628
           */

15629
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

15630
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

15631


15632
          /*

15633
           * Setup function pointers and call mdlInitializeSizes via

15634
           * simulink.c

15635
           */

15636
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

15637
          mxDestroyArray(plhs[0]);

15638
          mxDestroyArray(prhs[0]);

15639
          mxDestroyArray(prhs[1]);

15640
          mxDestroyArray(prhs[2]);

15641
          mxDestroyArray(prhs[3]);

15642
        }

15643


15644
#else

15645


15646
        {

15647
          LeadLagFilter_sf(childS);

15648
          sfcnInitializeSizes(childS);

15649
        }

15650


15651
#endif

15652


15653
        sfcnInitializeSampleTimes(childS);

15654


15655
        /* adjust sample time */

15656
        ssSetSampleTime(childS, 0, 0.0);

15657
        ssSetOffsetTime(childS, 0, 0.0);

15658
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

15659


15660
        /* set compiled values of dynamic vector attributes */

15661
        ssSetNumNonsampledZCs(childS, 0);

15662


15663
        /* Update connectivity flags for each port */

15664
        _ssSetInputPortConnected(childS, 0, 1);

15665
        _ssSetInputPortConnected(childS, 1, 1);

15666
        _ssSetInputPortConnected(childS, 2, 1);

15667
        _ssSetInputPortConnected(childS, 3, 1);

15668
        _ssSetInputPortConnected(childS, 4, 1);

15669
        _ssSetInputPortConnected(childS, 5, 1);

15670
        _ssSetInputPortConnected(childS, 6, 1);

15671
        _ssSetOutputPortConnected(childS, 0, 1);

15672
        _ssSetOutputPortBeingMerged(childS, 0, 0);

15673


15674
        /* Update the BufferDstPort flags for each input port */

15675
        _ssSetInputPortBufferDstPort(childS, 0, -1);

15676
        _ssSetInputPortBufferDstPort(childS, 1, -1);

15677
        _ssSetInputPortBufferDstPort(childS, 2, -1);

15678
        _ssSetInputPortBufferDstPort(childS, 3, -1);

15679
        _ssSetInputPortBufferDstPort(childS, 4, -1);

15680
        _ssSetInputPortBufferDstPort(childS, 5, -1);

15681
        _ssSetInputPortBufferDstPort(childS, 6, -1);

15682
      }

15683


15684
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S131>/Generated S-Function4 (LagFilter_sf) */

15685
      {

15686
        SimStruct *childS = ssGetSFunction(rts, 58);

15687


15688
        /* timing info */

15689
        time_T *sfcnPeriod;

15690
        time_T *sfcnOffset;

15691
        int_T *sfcnTsMap;

15692
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

15693
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

15694
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

15695
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

15696
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

15697
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

15698
        (void) memset((void*)sfcnPeriod, 0,

15699
                      sizeof(time_T)*1);

15700
        (void) memset((void*)sfcnOffset, 0,

15701
                      sizeof(time_T)*1);

15702
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

15703
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

15704
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

15705


15706
        /* Set up the mdlInfo pointer */

15707
# ifdef USE_RTMODEL

15708


15709
        {

15710
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

15711
              struct _ssBlkInfo2));

15712
          ss_VALIDATE_MEMORY(rts,blkInfo2);

15713
          ssSetBlkInfo2Ptr(childS, blkInfo2);

15714
        }

15715


15716
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

15717


15718
# else

15719


15720
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

15721


15722
# endif                                /* USE_RTMODEL */

15723


15724
        /* Allocate memory of model methods 2 */

15725
        {

15726
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

15727
            malloc(sizeof(struct _ssSFcnModelMethods2));

15728
          ss_VALIDATE_MEMORY(rts,methods2);

15729
          ssSetModelMethods2(childS, methods2);

15730
        }

15731


15732
        /* Allocate memory of model methods 3 */

15733
        {

15734
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

15735
            malloc(sizeof(struct _ssSFcnModelMethods3));

15736
          ss_VALIDATE_MEMORY(rts,methods3);

15737
          ssSetModelMethods3(childS, methods3);

15738
        }

15739


15740
        /* Allocate memory for states auxilliary information */

15741
        {

15742
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

15743
            (sizeof(struct _ssStatesInfo2));

15744
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

15745
            malloc(sizeof(ssPeriodicStatesInfo));

15746
          ss_VALIDATE_MEMORY(rts,statesInfo2);

15747
          ssSetStatesInfo2(childS, statesInfo2);

15748
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

15749
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

15750
        }

15751


15752
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

15753
          RegNumInputPorts);

15754
        ssSetRegNumInputPortsFcnArg(childS,childS);

15755


15756
        /* inputs */

15757
        {

15758
          struct _ssPortInputs *inputPortInfo =

15759
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

15760
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

15761
          _ssSetNumInputPorts(childS, 6);

15762
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

15763


15764
          /* port 0 */

15765
          {

15766
            real32_T const **sfcnUPtrs = (real32_T const **)

15767
              malloc(1 * sizeof(real32_T *));

15768
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15769
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15770
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

15771
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

15772
            _ssSetInputPortNumDimensions(childS, 0, 1);

15773
            ssSetInputPortWidth(childS, 0, 1);

15774
          }

15775


15776
          /* port 1 */

15777
          {

15778
            int8_T const **sfcnUPtrs = (int8_T const **)

15779
              malloc(1 * sizeof(int8_T *));

15780
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15781
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

15782
              ssGetLocalBlockIO(rts))->DataTypeConversion3_d;

15783
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

15784
            _ssSetInputPortNumDimensions(childS, 1, 1);

15785
            ssSetInputPortWidth(childS, 1, 1);

15786
          }

15787


15788
          /* port 2 */

15789
          {

15790
            real32_T const **sfcnUPtrs = (real32_T const **)

15791
              malloc(1 * sizeof(real32_T *));

15792
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15793
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

15794
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

15795
            _ssSetInputPortNumDimensions(childS, 2, 1);

15796
            ssSetInputPortWidth(childS, 2, 1);

15797
          }

15798


15799
          /* port 3 */

15800
          {

15801
            real32_T const **sfcnUPtrs = (real32_T const **)

15802
              malloc(1 * sizeof(real32_T *));

15803
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15804
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15805
              ssGetLocalBlockIO(rts))->Switch_bg;

15806
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

15807
            _ssSetInputPortNumDimensions(childS, 3, 1);

15808
            ssSetInputPortWidth(childS, 3, 1);

15809
          }

15810


15811
          /* port 4 */

15812
          {

15813
            real32_T const **sfcnUPtrs = (real32_T const **)

15814
              malloc(1 * sizeof(real32_T *));

15815
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15816
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15817
              ssGetLocalBlockIO(rts))->Switch_bg;

15818
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

15819
            _ssSetInputPortNumDimensions(childS, 4, 1);

15820
            ssSetInputPortWidth(childS, 4, 1);

15821
          }

15822


15823
          /* port 5 */

15824
          {

15825
            real32_T const **sfcnUPtrs = (real32_T const **)

15826
              malloc(1 * sizeof(real32_T *));

15827
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

15828
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

15829
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_f;

15830
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

15831
            _ssSetInputPortNumDimensions(childS, 5, 1);

15832
            ssSetInputPortWidth(childS, 5, 1);

15833
          }

15834
        }

15835


15836
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

15837
          RegNumOutputPorts);

15838
        ssSetRegNumOutputPortsFcnArg(childS,childS);

15839


15840
        /* outputs */

15841
        {

15842
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

15843
            calloc(1, sizeof(struct _ssPortOutputs));

15844
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

15845
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

15846
          _ssSetNumOutputPorts(childS, 1);

15847


15848
          /* port 0 */

15849
          {

15850
            _ssSetOutputPortNumDimensions(childS, 0, 1);

15851
            ssSetOutputPortWidth(childS, 0, 1);

15852
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

15853
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_m));

15854
          }

15855
        }

15856


15857
        /* path info */

15858
        _ssSetModelName(childS, "LagFilter_sf");

15859
        _ssSetPath(childS,

15860
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/ lag filter/Generated S-Function4");

15861
        if (ssGetRTModel(rts) == (NULL)) {

15862
          _ssSetParentSS(childS, rts);

15863
          _ssSetRootSS(childS, ssGetRootSS(rts));

15864
        } else {

15865
          ssSetRTModel(childS,ssGetRTModel(rts));

15866
          _ssSetParentSS(childS, (NULL));

15867
          _ssSetRootSS(childS, childS);

15868
        }

15869


15870
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

15871


15872
        /* work vectors */

15873
        {

15874
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

15875
            (4 * sizeof(struct _ssDWorkRecord));

15876
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

15877
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

15878
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

15879
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

15880
          ssSetSFcnDWork(childS, dWorkRecord);

15881
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

15882
          _ssSetNumDWork(childS, 4);

15883


15884
          /* DWORK0 */

15885
          ssSetDWorkWidth(childS, 0, 1);

15886
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

15887
          ssSetDWorkComplexSignal(childS, 0, 0);

15888
          ssSetDWorkUsedAsDState(childS, 0, 1);

15889
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 196))[0]);

15890


15891
          /* DWORK1 */

15892
          ssSetDWorkWidth(childS, 1, 1);

15893
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

15894
          ssSetDWorkComplexSignal(childS, 1, 0);

15895
          ssSetDWorkUsedAsDState(childS, 1, 1);

15896
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 197))[0]);

15897


15898
          /* DWORK2 */

15899
          ssSetDWorkWidth(childS, 2, 1);

15900
          ssSetDWorkDataType(childS, 2,SS_INT8);

15901
          ssSetDWorkComplexSignal(childS, 2, 0);

15902
          ssSetDWorkUsedAsDState(childS, 2, 1);

15903
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 423))[0]);

15904


15905
          /* DWORK3 */

15906
          ssSetDWorkWidth(childS, 3, 1);

15907
          ssSetDWorkDataType(childS, 3,SS_INT8);

15908
          ssSetDWorkComplexSignal(childS, 3, 0);

15909
          ssSetDWorkUsedAsDState(childS, 3, 1);

15910
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 424))[0]);

15911
        }

15912


15913
        (childS)->regDataType.arg1 = ((void *)(childS));

15914
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

15915
          FcnSetErrorStatus);

15916
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

15917
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

15918
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

15919
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

15920


15921
        /* registration */

15922
#if defined(MATLAB_MEX_FILE)

15923


15924
        {

15925
          int_T i;

15926
          mxArray *plhs[1];

15927
          mxArray *prhs[4];

15928
          double *pr;

15929
          volatile int_T *intS = (int_T *)&childS;

15930
          int_T addrlen = sizeof(SimStruct *);

15931
          int_T m = addrlen/sizeof(int_T) + 1;

15932
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

15933
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

15934
          pr = mxGetPr(prhs[1]);

15935
          for (i = 0; i < m - 1; i++) {

15936
            pr[i] = (double)intS[i];

15937
          }

15938


15939
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

15940
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

15941
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

15942


15943
          /* Reset port dimensions info functions because the S-function

15944
           * and accelerator mex-files explicitly set their dimensions,

15945
           * i.e., they are not dynamically sized. For this case, the

15946
           * mex-file is responsible for the dimensions info memory

15947
           * and Simulink should not free it. This is achieved by

15948
           * setting the following two methods to NULL.

15949
           */

15950
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

15951
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

15952


15953
          /*

15954
           * Setup function pointers and call mdlInitializeSizes via

15955
           * simulink.c

15956
           */

15957
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

15958
          mxDestroyArray(plhs[0]);

15959
          mxDestroyArray(prhs[0]);

15960
          mxDestroyArray(prhs[1]);

15961
          mxDestroyArray(prhs[2]);

15962
          mxDestroyArray(prhs[3]);

15963
        }

15964


15965
#else

15966


15967
        {

15968
          LagFilter_sf(childS);

15969
          sfcnInitializeSizes(childS);

15970
        }

15971


15972
#endif

15973


15974
        sfcnInitializeSampleTimes(childS);

15975


15976
        /* adjust sample time */

15977
        ssSetSampleTime(childS, 0, 0.0);

15978
        ssSetOffsetTime(childS, 0, 0.0);

15979
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

15980


15981
        /* set compiled values of dynamic vector attributes */

15982
        ssSetNumNonsampledZCs(childS, 0);

15983


15984
        /* Update connectivity flags for each port */

15985
        _ssSetInputPortConnected(childS, 0, 1);

15986
        _ssSetInputPortConnected(childS, 1, 1);

15987
        _ssSetInputPortConnected(childS, 2, 1);

15988
        _ssSetInputPortConnected(childS, 3, 1);

15989
        _ssSetInputPortConnected(childS, 4, 1);

15990
        _ssSetInputPortConnected(childS, 5, 1);

15991
        _ssSetOutputPortConnected(childS, 0, 1);

15992
        _ssSetOutputPortBeingMerged(childS, 0, 0);

15993


15994
        /* Update the BufferDstPort flags for each input port */

15995
        _ssSetInputPortBufferDstPort(childS, 0, -1);

15996
        _ssSetInputPortBufferDstPort(childS, 1, -1);

15997
        _ssSetInputPortBufferDstPort(childS, 2, -1);

15998
        _ssSetInputPortBufferDstPort(childS, 3, -1);

15999
        _ssSetInputPortBufferDstPort(childS, 4, -1);

16000
        _ssSetInputPortBufferDstPort(childS, 5, -1);

16001
      }

16002


16003
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S155>/Generated S-Function1 (SaturationLimiter_sf) */

16004
      {

16005
        SimStruct *childS = ssGetSFunction(rts, 59);

16006


16007
        /* timing info */

16008
        time_T *sfcnPeriod;

16009
        time_T *sfcnOffset;

16010
        int_T *sfcnTsMap;

16011
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

16012
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

16013
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

16014
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

16015
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

16016
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

16017
        (void) memset((void*)sfcnPeriod, 0,

16018
                      sizeof(time_T)*1);

16019
        (void) memset((void*)sfcnOffset, 0,

16020
                      sizeof(time_T)*1);

16021
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

16022
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

16023
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

16024


16025
        /* Set up the mdlInfo pointer */

16026
# ifdef USE_RTMODEL

16027


16028
        {

16029
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

16030
              struct _ssBlkInfo2));

16031
          ss_VALIDATE_MEMORY(rts,blkInfo2);

16032
          ssSetBlkInfo2Ptr(childS, blkInfo2);

16033
        }

16034


16035
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

16036


16037
# else

16038


16039
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

16040


16041
# endif                                /* USE_RTMODEL */

16042


16043
        /* Allocate memory of model methods 2 */

16044
        {

16045
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

16046
            malloc(sizeof(struct _ssSFcnModelMethods2));

16047
          ss_VALIDATE_MEMORY(rts,methods2);

16048
          ssSetModelMethods2(childS, methods2);

16049
        }

16050


16051
        /* Allocate memory of model methods 3 */

16052
        {

16053
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

16054
            malloc(sizeof(struct _ssSFcnModelMethods3));

16055
          ss_VALIDATE_MEMORY(rts,methods3);

16056
          ssSetModelMethods3(childS, methods3);

16057
        }

16058


16059
        /* Allocate memory for states auxilliary information */

16060
        {

16061
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

16062
            (sizeof(struct _ssStatesInfo2));

16063
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

16064
            malloc(sizeof(ssPeriodicStatesInfo));

16065
          ss_VALIDATE_MEMORY(rts,statesInfo2);

16066
          ssSetStatesInfo2(childS, statesInfo2);

16067
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

16068
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

16069
        }

16070


16071
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

16072
          RegNumInputPorts);

16073
        ssSetRegNumInputPortsFcnArg(childS,childS);

16074


16075
        /* inputs */

16076
        {

16077
          struct _ssPortInputs *inputPortInfo =

16078
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

16079
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

16080
          _ssSetNumInputPorts(childS, 3);

16081
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

16082


16083
          /* port 0 */

16084
          {

16085
            real32_T const **sfcnUPtrs = (real32_T const **)

16086
              malloc(1 * sizeof(real32_T *));

16087
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16088
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

16089
              ssGetLocalBlockIO(rts))->Divide_c;

16090
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

16091
            _ssSetInputPortNumDimensions(childS, 0, 1);

16092
            ssSetInputPortWidth(childS, 0, 1);

16093
          }

16094


16095
          /* port 1 */

16096
          {

16097
            real32_T const **sfcnUPtrs = (real32_T const **)

16098
              malloc(1 * sizeof(real32_T *));

16099
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16100
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

16101
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

16102
            _ssSetInputPortNumDimensions(childS, 1, 1);

16103
            ssSetInputPortWidth(childS, 1, 1);

16104
          }

16105


16106
          /* port 2 */

16107
          {

16108
            real32_T const **sfcnUPtrs = (real32_T const **)

16109
              malloc(1 * sizeof(real32_T *));

16110
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16111
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

16112
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

16113
            _ssSetInputPortNumDimensions(childS, 2, 1);

16114
            ssSetInputPortWidth(childS, 2, 1);

16115
          }

16116
        }

16117


16118
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

16119
          RegNumOutputPorts);

16120
        ssSetRegNumOutputPortsFcnArg(childS,childS);

16121


16122
        /* outputs */

16123
        {

16124
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

16125
            calloc(1, sizeof(struct _ssPortOutputs));

16126
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

16127
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

16128
          _ssSetNumOutputPorts(childS, 1);

16129


16130
          /* port 0 */

16131
          {

16132
            _ssSetOutputPortNumDimensions(childS, 0, 1);

16133
            ssSetOutputPortWidth(childS, 0, 1);

16134
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

16135
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_o));

16136
          }

16137
        }

16138


16139
        /* path info */

16140
        _ssSetModelName(childS, "SaturationLimiter_sf");

16141
        _ssSetPath(childS,

16142
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Saturation Limiter2/Generated S-Function1");

16143
        if (ssGetRTModel(rts) == (NULL)) {

16144
          _ssSetParentSS(childS, rts);

16145
          _ssSetRootSS(childS, ssGetRootSS(rts));

16146
        } else {

16147
          ssSetRTModel(childS,ssGetRTModel(rts));

16148
          _ssSetParentSS(childS, (NULL));

16149
          _ssSetRootSS(childS, childS);

16150
        }

16151


16152
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

16153
        (childS)->regDataType.arg1 = ((void *)(childS));

16154
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

16155
          FcnSetErrorStatus);

16156
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

16157
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

16158
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

16159
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

16160


16161
        /* registration */

16162
#if defined(MATLAB_MEX_FILE)

16163


16164
        {

16165
          int_T i;

16166
          mxArray *plhs[1];

16167
          mxArray *prhs[4];

16168
          double *pr;

16169
          volatile int_T *intS = (int_T *)&childS;

16170
          int_T addrlen = sizeof(SimStruct *);

16171
          int_T m = addrlen/sizeof(int_T) + 1;

16172
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

16173
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

16174
          pr = mxGetPr(prhs[1]);

16175
          for (i = 0; i < m - 1; i++) {

16176
            pr[i] = (double)intS[i];

16177
          }

16178


16179
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

16180
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

16181
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

16182


16183
          /* Reset port dimensions info functions because the S-function

16184
           * and accelerator mex-files explicitly set their dimensions,

16185
           * i.e., they are not dynamically sized. For this case, the

16186
           * mex-file is responsible for the dimensions info memory

16187
           * and Simulink should not free it. This is achieved by

16188
           * setting the following two methods to NULL.

16189
           */

16190
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

16191
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

16192


16193
          /*

16194
           * Setup function pointers and call mdlInitializeSizes via

16195
           * simulink.c

16196
           */

16197
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

16198
          mxDestroyArray(plhs[0]);

16199
          mxDestroyArray(prhs[0]);

16200
          mxDestroyArray(prhs[1]);

16201
          mxDestroyArray(prhs[2]);

16202
          mxDestroyArray(prhs[3]);

16203
        }

16204


16205
#else

16206


16207
        {

16208
          SaturationLimiter_sf(childS);

16209
          sfcnInitializeSizes(childS);

16210
        }

16211


16212
#endif

16213


16214
        sfcnInitializeSampleTimes(childS);

16215


16216
        /* adjust sample time */

16217
        ssSetSampleTime(childS, 0, 0.005);

16218
        ssSetOffsetTime(childS, 0, 0.0);

16219
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];

16220


16221
        /* set compiled values of dynamic vector attributes */

16222
        ssSetNumNonsampledZCs(childS, 0);

16223


16224
        /* Update connectivity flags for each port */

16225
        _ssSetInputPortConnected(childS, 0, 1);

16226
        _ssSetInputPortConnected(childS, 1, 1);

16227
        _ssSetInputPortConnected(childS, 2, 1);

16228
        _ssSetOutputPortConnected(childS, 0, 1);

16229
        _ssSetOutputPortBeingMerged(childS, 0, 0);

16230


16231
        /* Update the BufferDstPort flags for each input port */

16232
        _ssSetInputPortBufferDstPort(childS, 0, -1);

16233
        _ssSetInputPortBufferDstPort(childS, 1, -1);

16234
        _ssSetInputPortBufferDstPort(childS, 2, -1);

16235
      }

16236


16237
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S128>/Generated S-Function6 (Res180_sf) */

16238
      {

16239
        SimStruct *childS = ssGetSFunction(rts, 60);

16240


16241
        /* timing info */

16242
        time_T *sfcnPeriod;

16243
        time_T *sfcnOffset;

16244
        int_T *sfcnTsMap;

16245
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

16246
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

16247
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

16248
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

16249
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

16250
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

16251
        (void) memset((void*)sfcnPeriod, 0,

16252
                      sizeof(time_T)*1);

16253
        (void) memset((void*)sfcnOffset, 0,

16254
                      sizeof(time_T)*1);

16255
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

16256
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

16257
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

16258


16259
        /* Set up the mdlInfo pointer */

16260
# ifdef USE_RTMODEL

16261


16262
        {

16263
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

16264
              struct _ssBlkInfo2));

16265
          ss_VALIDATE_MEMORY(rts,blkInfo2);

16266
          ssSetBlkInfo2Ptr(childS, blkInfo2);

16267
        }

16268


16269
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

16270


16271
# else

16272


16273
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

16274


16275
# endif                                /* USE_RTMODEL */

16276


16277
        /* Allocate memory of model methods 2 */

16278
        {

16279
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

16280
            malloc(sizeof(struct _ssSFcnModelMethods2));

16281
          ss_VALIDATE_MEMORY(rts,methods2);

16282
          ssSetModelMethods2(childS, methods2);

16283
        }

16284


16285
        /* Allocate memory of model methods 3 */

16286
        {

16287
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

16288
            malloc(sizeof(struct _ssSFcnModelMethods3));

16289
          ss_VALIDATE_MEMORY(rts,methods3);

16290
          ssSetModelMethods3(childS, methods3);

16291
        }

16292


16293
        /* Allocate memory for states auxilliary information */

16294
        {

16295
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

16296
            (sizeof(struct _ssStatesInfo2));

16297
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

16298
            malloc(sizeof(ssPeriodicStatesInfo));

16299
          ss_VALIDATE_MEMORY(rts,statesInfo2);

16300
          ssSetStatesInfo2(childS, statesInfo2);

16301
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

16302
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

16303
        }

16304


16305
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

16306
          RegNumInputPorts);

16307
        ssSetRegNumInputPortsFcnArg(childS,childS);

16308


16309
        /* inputs */

16310
        {

16311
          struct _ssPortInputs *inputPortInfo =

16312
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

16313
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

16314
          _ssSetNumInputPorts(childS, 1);

16315
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

16316


16317
          /* port 0 */

16318
          {

16319
            real32_T const **sfcnUPtrs = (real32_T const **)

16320
              malloc(1 * sizeof(real32_T *));

16321
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16322
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

16323
              ssGetLocalBlockIO(rts))->Sum3_g;

16324
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

16325
            _ssSetInputPortNumDimensions(childS, 0, 1);

16326
            ssSetInputPortWidth(childS, 0, 1);

16327
          }

16328
        }

16329


16330
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

16331
          RegNumOutputPorts);

16332
        ssSetRegNumOutputPortsFcnArg(childS,childS);

16333


16334
        /* outputs */

16335
        {

16336
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

16337
            calloc(1, sizeof(struct _ssPortOutputs));

16338
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

16339
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

16340
          _ssSetNumOutputPorts(childS, 1);

16341


16342
          /* port 0 */

16343
          {

16344
            _ssSetOutputPortNumDimensions(childS, 0, 1);

16345
            ssSetOutputPortWidth(childS, 0, 1);

16346
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

16347
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_g));

16348
          }

16349
        }

16350


16351
        /* path info */

16352
        _ssSetModelName(childS, "Res180_sf");

16353
        _ssSetPath(childS,

16354
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Generated S-Function6");

16355
        if (ssGetRTModel(rts) == (NULL)) {

16356
          _ssSetParentSS(childS, rts);

16357
          _ssSetRootSS(childS, ssGetRootSS(rts));

16358
        } else {

16359
          ssSetRTModel(childS,ssGetRTModel(rts));

16360
          _ssSetParentSS(childS, (NULL));

16361
          _ssSetRootSS(childS, childS);

16362
        }

16363


16364
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

16365
        (childS)->regDataType.arg1 = ((void *)(childS));

16366
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

16367
          FcnSetErrorStatus);

16368
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

16369
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

16370
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

16371
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

16372


16373
        /* registration */

16374
#if defined(MATLAB_MEX_FILE)

16375


16376
        {

16377
          int_T i;

16378
          mxArray *plhs[1];

16379
          mxArray *prhs[4];

16380
          double *pr;

16381
          volatile int_T *intS = (int_T *)&childS;

16382
          int_T addrlen = sizeof(SimStruct *);

16383
          int_T m = addrlen/sizeof(int_T) + 1;

16384
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

16385
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

16386
          pr = mxGetPr(prhs[1]);

16387
          for (i = 0; i < m - 1; i++) {

16388
            pr[i] = (double)intS[i];

16389
          }

16390


16391
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

16392
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

16393
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

16394


16395
          /* Reset port dimensions info functions because the S-function

16396
           * and accelerator mex-files explicitly set their dimensions,

16397
           * i.e., they are not dynamically sized. For this case, the

16398
           * mex-file is responsible for the dimensions info memory

16399
           * and Simulink should not free it. This is achieved by

16400
           * setting the following two methods to NULL.

16401
           */

16402
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

16403
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

16404


16405
          /*

16406
           * Setup function pointers and call mdlInitializeSizes via

16407
           * simulink.c

16408
           */

16409
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

16410
          mxDestroyArray(plhs[0]);

16411
          mxDestroyArray(prhs[0]);

16412
          mxDestroyArray(prhs[1]);

16413
          mxDestroyArray(prhs[2]);

16414
          mxDestroyArray(prhs[3]);

16415
        }

16416


16417
#else

16418


16419
        {

16420
          Res180_sf(childS);

16421
          sfcnInitializeSizes(childS);

16422
        }

16423


16424
#endif

16425


16426
        sfcnInitializeSampleTimes(childS);

16427


16428
        /* adjust sample time */

16429
        ssSetSampleTime(childS, 0, 0.0);

16430
        ssSetOffsetTime(childS, 0, 0.0);

16431
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

16432


16433
        /* set compiled values of dynamic vector attributes */

16434
        ssSetNumNonsampledZCs(childS, 0);

16435


16436
        /* Update connectivity flags for each port */

16437
        _ssSetInputPortConnected(childS, 0, 1);

16438
        _ssSetOutputPortConnected(childS, 0, 1);

16439
        _ssSetOutputPortBeingMerged(childS, 0, 0);

16440


16441
        /* Update the BufferDstPort flags for each input port */

16442
        _ssSetInputPortBufferDstPort(childS, 0, -1);

16443
      }

16444


16445
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S154>/Generated S-Function1 (SaturationLimiter_sf) */

16446
      {

16447
        SimStruct *childS = ssGetSFunction(rts, 61);

16448


16449
        /* timing info */

16450
        time_T *sfcnPeriod;

16451
        time_T *sfcnOffset;

16452
        int_T *sfcnTsMap;

16453
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

16454
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

16455
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

16456
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

16457
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

16458
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

16459
        (void) memset((void*)sfcnPeriod, 0,

16460
                      sizeof(time_T)*1);

16461
        (void) memset((void*)sfcnOffset, 0,

16462
                      sizeof(time_T)*1);

16463
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

16464
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

16465
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

16466


16467
        /* Set up the mdlInfo pointer */

16468
# ifdef USE_RTMODEL

16469


16470
        {

16471
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

16472
              struct _ssBlkInfo2));

16473
          ss_VALIDATE_MEMORY(rts,blkInfo2);

16474
          ssSetBlkInfo2Ptr(childS, blkInfo2);

16475
        }

16476


16477
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

16478


16479
# else

16480


16481
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

16482


16483
# endif                                /* USE_RTMODEL */

16484


16485
        /* Allocate memory of model methods 2 */

16486
        {

16487
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

16488
            malloc(sizeof(struct _ssSFcnModelMethods2));

16489
          ss_VALIDATE_MEMORY(rts,methods2);

16490
          ssSetModelMethods2(childS, methods2);

16491
        }

16492


16493
        /* Allocate memory of model methods 3 */

16494
        {

16495
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

16496
            malloc(sizeof(struct _ssSFcnModelMethods3));

16497
          ss_VALIDATE_MEMORY(rts,methods3);

16498
          ssSetModelMethods3(childS, methods3);

16499
        }

16500


16501
        /* Allocate memory for states auxilliary information */

16502
        {

16503
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

16504
            (sizeof(struct _ssStatesInfo2));

16505
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

16506
            malloc(sizeof(ssPeriodicStatesInfo));

16507
          ss_VALIDATE_MEMORY(rts,statesInfo2);

16508
          ssSetStatesInfo2(childS, statesInfo2);

16509
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

16510
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

16511
        }

16512


16513
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

16514
          RegNumInputPorts);

16515
        ssSetRegNumInputPortsFcnArg(childS,childS);

16516


16517
        /* inputs */

16518
        {

16519
          struct _ssPortInputs *inputPortInfo =

16520
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

16521
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

16522
          _ssSetNumInputPorts(childS, 3);

16523
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

16524


16525
          /* port 0 */

16526
          {

16527
            real32_T const **sfcnUPtrs = (real32_T const **)

16528
              malloc(1 * sizeof(real32_T *));

16529
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16530
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

16531
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_g;

16532
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

16533
            _ssSetInputPortNumDimensions(childS, 0, 1);

16534
            ssSetInputPortWidth(childS, 0, 1);

16535
          }

16536


16537
          /* port 1 */

16538
          {

16539
            real32_T const **sfcnUPtrs = (real32_T const **)

16540
              malloc(1 * sizeof(real32_T *));

16541
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16542
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;

16543
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

16544
            _ssSetInputPortNumDimensions(childS, 1, 1);

16545
            ssSetInputPortWidth(childS, 1, 1);

16546
          }

16547


16548
          /* port 2 */

16549
          {

16550
            real32_T const **sfcnUPtrs = (real32_T const **)

16551
              malloc(1 * sizeof(real32_T *));

16552
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16553
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;

16554
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

16555
            _ssSetInputPortNumDimensions(childS, 2, 1);

16556
            ssSetInputPortWidth(childS, 2, 1);

16557
          }

16558
        }

16559


16560
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

16561
          RegNumOutputPorts);

16562
        ssSetRegNumOutputPortsFcnArg(childS,childS);

16563


16564
        /* outputs */

16565
        {

16566
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

16567
            calloc(1, sizeof(struct _ssPortOutputs));

16568
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

16569
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

16570
          _ssSetNumOutputPorts(childS, 1);

16571


16572
          /* port 0 */

16573
          {

16574
            _ssSetOutputPortNumDimensions(childS, 0, 1);

16575
            ssSetOutputPortWidth(childS, 0, 1);

16576
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

16577
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_m));

16578
          }

16579
        }

16580


16581
        /* path info */

16582
        _ssSetModelName(childS, "SaturationLimiter_sf");

16583
        _ssSetPath(childS,

16584
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Saturation Limiter1/Generated S-Function1");

16585
        if (ssGetRTModel(rts) == (NULL)) {

16586
          _ssSetParentSS(childS, rts);

16587
          _ssSetRootSS(childS, ssGetRootSS(rts));

16588
        } else {

16589
          ssSetRTModel(childS,ssGetRTModel(rts));

16590
          _ssSetParentSS(childS, (NULL));

16591
          _ssSetRootSS(childS, childS);

16592
        }

16593


16594
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

16595
        (childS)->regDataType.arg1 = ((void *)(childS));

16596
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

16597
          FcnSetErrorStatus);

16598
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

16599
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

16600
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

16601
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

16602


16603
        /* registration */

16604
#if defined(MATLAB_MEX_FILE)

16605


16606
        {

16607
          int_T i;

16608
          mxArray *plhs[1];

16609
          mxArray *prhs[4];

16610
          double *pr;

16611
          volatile int_T *intS = (int_T *)&childS;

16612
          int_T addrlen = sizeof(SimStruct *);

16613
          int_T m = addrlen/sizeof(int_T) + 1;

16614
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

16615
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

16616
          pr = mxGetPr(prhs[1]);

16617
          for (i = 0; i < m - 1; i++) {

16618
            pr[i] = (double)intS[i];

16619
          }

16620


16621
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

16622
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

16623
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

16624


16625
          /* Reset port dimensions info functions because the S-function

16626
           * and accelerator mex-files explicitly set their dimensions,

16627
           * i.e., they are not dynamically sized. For this case, the

16628
           * mex-file is responsible for the dimensions info memory

16629
           * and Simulink should not free it. This is achieved by

16630
           * setting the following two methods to NULL.

16631
           */

16632
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

16633
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

16634


16635
          /*

16636
           * Setup function pointers and call mdlInitializeSizes via

16637
           * simulink.c

16638
           */

16639
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

16640
          mxDestroyArray(plhs[0]);

16641
          mxDestroyArray(prhs[0]);

16642
          mxDestroyArray(prhs[1]);

16643
          mxDestroyArray(prhs[2]);

16644
          mxDestroyArray(prhs[3]);

16645
        }

16646


16647
#else

16648


16649
        {

16650
          SaturationLimiter_sf(childS);

16651
          sfcnInitializeSizes(childS);

16652
        }

16653


16654
#endif

16655


16656
        sfcnInitializeSampleTimes(childS);

16657


16658
        /* adjust sample time */

16659
        ssSetSampleTime(childS, 0, 0.0);

16660
        ssSetOffsetTime(childS, 0, 0.0);

16661
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

16662


16663
        /* set compiled values of dynamic vector attributes */

16664
        ssSetNumNonsampledZCs(childS, 0);

16665


16666
        /* Update connectivity flags for each port */

16667
        _ssSetInputPortConnected(childS, 0, 1);

16668
        _ssSetInputPortConnected(childS, 1, 1);

16669
        _ssSetInputPortConnected(childS, 2, 1);

16670
        _ssSetOutputPortConnected(childS, 0, 1);

16671
        _ssSetOutputPortBeingMerged(childS, 0, 0);

16672


16673
        /* Update the BufferDstPort flags for each input port */

16674
        _ssSetInputPortBufferDstPort(childS, 0, -1);

16675
        _ssSetInputPortBufferDstPort(childS, 1, -1);

16676
        _ssSetInputPortBufferDstPort(childS, 2, -1);

16677
      }

16678


16679
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S158>/Generated S-Function (Gain_sf) */

16680
      {

16681
        SimStruct *childS = ssGetSFunction(rts, 62);

16682


16683
        /* timing info */

16684
        time_T *sfcnPeriod;

16685
        time_T *sfcnOffset;

16686
        int_T *sfcnTsMap;

16687
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

16688
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

16689
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

16690
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

16691
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

16692
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

16693
        (void) memset((void*)sfcnPeriod, 0,

16694
                      sizeof(time_T)*1);

16695
        (void) memset((void*)sfcnOffset, 0,

16696
                      sizeof(time_T)*1);

16697
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

16698
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

16699
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

16700


16701
        /* Set up the mdlInfo pointer */

16702
# ifdef USE_RTMODEL

16703


16704
        {

16705
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

16706
              struct _ssBlkInfo2));

16707
          ss_VALIDATE_MEMORY(rts,blkInfo2);

16708
          ssSetBlkInfo2Ptr(childS, blkInfo2);

16709
        }

16710


16711
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

16712


16713
# else

16714


16715
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

16716


16717
# endif                                /* USE_RTMODEL */

16718


16719
        /* Allocate memory of model methods 2 */

16720
        {

16721
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

16722
            malloc(sizeof(struct _ssSFcnModelMethods2));

16723
          ss_VALIDATE_MEMORY(rts,methods2);

16724
          ssSetModelMethods2(childS, methods2);

16725
        }

16726


16727
        /* Allocate memory of model methods 3 */

16728
        {

16729
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

16730
            malloc(sizeof(struct _ssSFcnModelMethods3));

16731
          ss_VALIDATE_MEMORY(rts,methods3);

16732
          ssSetModelMethods3(childS, methods3);

16733
        }

16734


16735
        /* Allocate memory for states auxilliary information */

16736
        {

16737
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

16738
            (sizeof(struct _ssStatesInfo2));

16739
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

16740
            malloc(sizeof(ssPeriodicStatesInfo));

16741
          ss_VALIDATE_MEMORY(rts,statesInfo2);

16742
          ssSetStatesInfo2(childS, statesInfo2);

16743
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

16744
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

16745
        }

16746


16747
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

16748
          RegNumInputPorts);

16749
        ssSetRegNumInputPortsFcnArg(childS,childS);

16750


16751
        /* inputs */

16752
        {

16753
          struct _ssPortInputs *inputPortInfo =

16754
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

16755
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

16756
          _ssSetNumInputPorts(childS, 2);

16757
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

16758


16759
          /* port 0 */

16760
          {

16761
            real32_T const **sfcnUPtrs = (real32_T const **)

16762
              malloc(1 * sizeof(real32_T *));

16763
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16764
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

16765
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_m;

16766
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

16767
            _ssSetInputPortNumDimensions(childS, 0, 1);

16768
            ssSetInputPortWidth(childS, 0, 1);

16769
          }

16770


16771
          /* port 1 */

16772
          {

16773
            real32_T const **sfcnUPtrs = (real32_T const **)

16774
              malloc(1 * sizeof(real32_T *));

16775
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16776
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled122;

16777
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

16778
            _ssSetInputPortNumDimensions(childS, 1, 1);

16779
            ssSetInputPortWidth(childS, 1, 1);

16780
          }

16781
        }

16782


16783
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

16784
          RegNumOutputPorts);

16785
        ssSetRegNumOutputPortsFcnArg(childS,childS);

16786


16787
        /* outputs */

16788
        {

16789
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

16790
            calloc(1, sizeof(struct _ssPortOutputs));

16791
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

16792
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

16793
          _ssSetNumOutputPorts(childS, 1);

16794


16795
          /* port 0 */

16796
          {

16797
            _ssSetOutputPortNumDimensions(childS, 0, 1);

16798
            ssSetOutputPortWidth(childS, 0, 1);

16799
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

16800
              ssGetLocalBlockIO(rts))->GeneratedSFunction_f));

16801
          }

16802
        }

16803


16804
        /* path info */

16805
        _ssSetModelName(childS, "Gain_sf");

16806
        _ssSetPath(childS,

16807
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/gain2/Generated S-Function");

16808
        if (ssGetRTModel(rts) == (NULL)) {

16809
          _ssSetParentSS(childS, rts);

16810
          _ssSetRootSS(childS, ssGetRootSS(rts));

16811
        } else {

16812
          ssSetRTModel(childS,ssGetRTModel(rts));

16813
          _ssSetParentSS(childS, (NULL));

16814
          _ssSetRootSS(childS, childS);

16815
        }

16816


16817
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

16818
        (childS)->regDataType.arg1 = ((void *)(childS));

16819
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

16820
          FcnSetErrorStatus);

16821
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

16822
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

16823
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

16824
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

16825


16826
        /* registration */

16827
#if defined(MATLAB_MEX_FILE)

16828


16829
        {

16830
          int_T i;

16831
          mxArray *plhs[1];

16832
          mxArray *prhs[4];

16833
          double *pr;

16834
          volatile int_T *intS = (int_T *)&childS;

16835
          int_T addrlen = sizeof(SimStruct *);

16836
          int_T m = addrlen/sizeof(int_T) + 1;

16837
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

16838
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

16839
          pr = mxGetPr(prhs[1]);

16840
          for (i = 0; i < m - 1; i++) {

16841
            pr[i] = (double)intS[i];

16842
          }

16843


16844
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

16845
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

16846
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

16847


16848
          /* Reset port dimensions info functions because the S-function

16849
           * and accelerator mex-files explicitly set their dimensions,

16850
           * i.e., they are not dynamically sized. For this case, the

16851
           * mex-file is responsible for the dimensions info memory

16852
           * and Simulink should not free it. This is achieved by

16853
           * setting the following two methods to NULL.

16854
           */

16855
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

16856
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

16857


16858
          /*

16859
           * Setup function pointers and call mdlInitializeSizes via

16860
           * simulink.c

16861
           */

16862
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

16863
          mxDestroyArray(plhs[0]);

16864
          mxDestroyArray(prhs[0]);

16865
          mxDestroyArray(prhs[1]);

16866
          mxDestroyArray(prhs[2]);

16867
          mxDestroyArray(prhs[3]);

16868
        }

16869


16870
#else

16871


16872
        {

16873
          Gain_sf(childS);

16874
          sfcnInitializeSizes(childS);

16875
        }

16876


16877
#endif

16878


16879
        sfcnInitializeSampleTimes(childS);

16880


16881
        /* adjust sample time */

16882
        ssSetSampleTime(childS, 0, 0.0);

16883
        ssSetOffsetTime(childS, 0, 0.0);

16884
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

16885


16886
        /* set compiled values of dynamic vector attributes */

16887
        ssSetNumNonsampledZCs(childS, 0);

16888


16889
        /* Update connectivity flags for each port */

16890
        _ssSetInputPortConnected(childS, 0, 1);

16891
        _ssSetInputPortConnected(childS, 1, 1);

16892
        _ssSetOutputPortConnected(childS, 0, 1);

16893
        _ssSetOutputPortBeingMerged(childS, 0, 0);

16894


16895
        /* Update the BufferDstPort flags for each input port */

16896
        _ssSetInputPortBufferDstPort(childS, 0, -1);

16897
        _ssSetInputPortBufferDstPort(childS, 1, -1);

16898
      }

16899


16900
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S152>/Generated S-Function2 (LeadLagFilter_sf) */

16901
      {

16902
        SimStruct *childS = ssGetSFunction(rts, 63);

16903


16904
        /* timing info */

16905
        time_T *sfcnPeriod;

16906
        time_T *sfcnOffset;

16907
        int_T *sfcnTsMap;

16908
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

16909
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

16910
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

16911
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

16912
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

16913
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

16914
        (void) memset((void*)sfcnPeriod, 0,

16915
                      sizeof(time_T)*1);

16916
        (void) memset((void*)sfcnOffset, 0,

16917
                      sizeof(time_T)*1);

16918
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

16919
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

16920
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

16921


16922
        /* Set up the mdlInfo pointer */

16923
# ifdef USE_RTMODEL

16924


16925
        {

16926
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

16927
              struct _ssBlkInfo2));

16928
          ss_VALIDATE_MEMORY(rts,blkInfo2);

16929
          ssSetBlkInfo2Ptr(childS, blkInfo2);

16930
        }

16931


16932
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

16933


16934
# else

16935


16936
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

16937


16938
# endif                                /* USE_RTMODEL */

16939


16940
        /* Allocate memory of model methods 2 */

16941
        {

16942
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

16943
            malloc(sizeof(struct _ssSFcnModelMethods2));

16944
          ss_VALIDATE_MEMORY(rts,methods2);

16945
          ssSetModelMethods2(childS, methods2);

16946
        }

16947


16948
        /* Allocate memory of model methods 3 */

16949
        {

16950
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

16951
            malloc(sizeof(struct _ssSFcnModelMethods3));

16952
          ss_VALIDATE_MEMORY(rts,methods3);

16953
          ssSetModelMethods3(childS, methods3);

16954
        }

16955


16956
        /* Allocate memory for states auxilliary information */

16957
        {

16958
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

16959
            (sizeof(struct _ssStatesInfo2));

16960
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

16961
            malloc(sizeof(ssPeriodicStatesInfo));

16962
          ss_VALIDATE_MEMORY(rts,statesInfo2);

16963
          ssSetStatesInfo2(childS, statesInfo2);

16964
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

16965
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

16966
        }

16967


16968
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

16969
          RegNumInputPorts);

16970
        ssSetRegNumInputPortsFcnArg(childS,childS);

16971


16972
        /* inputs */

16973
        {

16974
          struct _ssPortInputs *inputPortInfo =

16975
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

16976
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

16977
          _ssSetNumInputPorts(childS, 7);

16978
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

16979


16980
          /* port 0 */

16981
          {

16982
            real32_T const **sfcnUPtrs = (real32_T const **)

16983
              malloc(1 * sizeof(real32_T *));

16984
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16985
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

16986
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

16987
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

16988
            _ssSetInputPortNumDimensions(childS, 0, 1);

16989
            ssSetInputPortWidth(childS, 0, 1);

16990
          }

16991


16992
          /* port 1 */

16993
          {

16994
            int8_T const **sfcnUPtrs = (int8_T const **)

16995
              malloc(1 * sizeof(int8_T *));

16996
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

16997
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

16998
              ssGetLocalBlockIO(rts))->DataTypeConversion1_h;

16999
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

17000
            _ssSetInputPortNumDimensions(childS, 1, 1);

17001
            ssSetInputPortWidth(childS, 1, 1);

17002
          }

17003


17004
          /* port 2 */

17005
          {

17006
            real32_T const **sfcnUPtrs = (real32_T const **)

17007
              malloc(1 * sizeof(real32_T *));

17008
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17009
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

17010
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

17011
            _ssSetInputPortNumDimensions(childS, 2, 1);

17012
            ssSetInputPortWidth(childS, 2, 1);

17013
          }

17014


17015
          /* port 3 */

17016
          {

17017
            real32_T const **sfcnUPtrs = (real32_T const **)

17018
              malloc(1 * sizeof(real32_T *));

17019
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17020
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

17021
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

17022
            _ssSetInputPortNumDimensions(childS, 3, 1);

17023
            ssSetInputPortWidth(childS, 3, 1);

17024
          }

17025


17026
          /* port 4 */

17027
          {

17028
            real32_T const **sfcnUPtrs = (real32_T const **)

17029
              malloc(1 * sizeof(real32_T *));

17030
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17031
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

17032
              ssGetLocalBlockIO(rts))->Sum4_d;

17033
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

17034
            _ssSetInputPortNumDimensions(childS, 4, 1);

17035
            ssSetInputPortWidth(childS, 4, 1);

17036
          }

17037


17038
          /* port 5 */

17039
          {

17040
            real32_T const **sfcnUPtrs = (real32_T const **)

17041
              malloc(1 * sizeof(real32_T *));

17042
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17043
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

17044
              ssGetLocalBlockIO(rts))->Sum4_d;

17045
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

17046
            _ssSetInputPortNumDimensions(childS, 5, 1);

17047
            ssSetInputPortWidth(childS, 5, 1);

17048
          }

17049


17050
          /* port 6 */

17051
          {

17052
            real32_T const **sfcnUPtrs = (real32_T const **)

17053
              malloc(1 * sizeof(real32_T *));

17054
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17055
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

17056
              ssGetLocalBlockIO(rts))->GeneratedSFunction_f;

17057
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

17058
            _ssSetInputPortNumDimensions(childS, 6, 1);

17059
            ssSetInputPortWidth(childS, 6, 1);

17060
          }

17061
        }

17062


17063
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

17064
          RegNumOutputPorts);

17065
        ssSetRegNumOutputPortsFcnArg(childS,childS);

17066


17067
        /* outputs */

17068
        {

17069
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

17070
            calloc(1, sizeof(struct _ssPortOutputs));

17071
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

17072
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

17073
          _ssSetNumOutputPorts(childS, 1);

17074


17075
          /* port 0 */

17076
          {

17077
            _ssSetOutputPortNumDimensions(childS, 0, 1);

17078
            ssSetOutputPortWidth(childS, 0, 1);

17079
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

17080
              ssGetLocalBlockIO(rts))->Saturation2_p));

17081
          }

17082
        }

17083


17084
        /* path info */

17085
        _ssSetModelName(childS, "LeadLagFilter_sf");

17086
        _ssSetPath(childS,

17087
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Lead lag1/Generated S-Function2");

17088
        if (ssGetRTModel(rts) == (NULL)) {

17089
          _ssSetParentSS(childS, rts);

17090
          _ssSetRootSS(childS, ssGetRootSS(rts));

17091
        } else {

17092
          ssSetRTModel(childS,ssGetRTModel(rts));

17093
          _ssSetParentSS(childS, (NULL));

17094
          _ssSetRootSS(childS, childS);

17095
        }

17096


17097
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

17098


17099
        /* work vectors */

17100
        {

17101
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

17102
            (4 * sizeof(struct _ssDWorkRecord));

17103
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

17104
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

17105
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

17106
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

17107
          ssSetSFcnDWork(childS, dWorkRecord);

17108
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

17109
          _ssSetNumDWork(childS, 4);

17110


17111
          /* DWORK0 */

17112
          ssSetDWorkWidth(childS, 0, 1);

17113
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

17114
          ssSetDWorkComplexSignal(childS, 0, 0);

17115
          ssSetDWorkUsedAsDState(childS, 0, 1);

17116
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 198))[0]);

17117


17118
          /* DWORK1 */

17119
          ssSetDWorkWidth(childS, 1, 1);

17120
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

17121
          ssSetDWorkComplexSignal(childS, 1, 0);

17122
          ssSetDWorkUsedAsDState(childS, 1, 1);

17123
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 199))[0]);

17124


17125
          /* DWORK2 */

17126
          ssSetDWorkWidth(childS, 2, 1);

17127
          ssSetDWorkDataType(childS, 2,SS_INT8);

17128
          ssSetDWorkComplexSignal(childS, 2, 0);

17129
          ssSetDWorkUsedAsDState(childS, 2, 1);

17130
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 425))[0]);

17131


17132
          /* DWORK3 */

17133
          ssSetDWorkWidth(childS, 3, 1);

17134
          ssSetDWorkDataType(childS, 3,SS_INT8);

17135
          ssSetDWorkComplexSignal(childS, 3, 0);

17136
          ssSetDWorkUsedAsDState(childS, 3, 1);

17137
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 426))[0]);

17138
        }

17139


17140
        (childS)->regDataType.arg1 = ((void *)(childS));

17141
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

17142
          FcnSetErrorStatus);

17143
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

17144
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

17145
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

17146
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

17147


17148
        /* registration */

17149
#if defined(MATLAB_MEX_FILE)

17150


17151
        {

17152
          int_T i;

17153
          mxArray *plhs[1];

17154
          mxArray *prhs[4];

17155
          double *pr;

17156
          volatile int_T *intS = (int_T *)&childS;

17157
          int_T addrlen = sizeof(SimStruct *);

17158
          int_T m = addrlen/sizeof(int_T) + 1;

17159
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

17160
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

17161
          pr = mxGetPr(prhs[1]);

17162
          for (i = 0; i < m - 1; i++) {

17163
            pr[i] = (double)intS[i];

17164
          }

17165


17166
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

17167
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

17168
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

17169


17170
          /* Reset port dimensions info functions because the S-function

17171
           * and accelerator mex-files explicitly set their dimensions,

17172
           * i.e., they are not dynamically sized. For this case, the

17173
           * mex-file is responsible for the dimensions info memory

17174
           * and Simulink should not free it. This is achieved by

17175
           * setting the following two methods to NULL.

17176
           */

17177
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

17178
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

17179


17180
          /*

17181
           * Setup function pointers and call mdlInitializeSizes via

17182
           * simulink.c

17183
           */

17184
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

17185
          mxDestroyArray(plhs[0]);

17186
          mxDestroyArray(prhs[0]);

17187
          mxDestroyArray(prhs[1]);

17188
          mxDestroyArray(prhs[2]);

17189
          mxDestroyArray(prhs[3]);

17190
        }

17191


17192
#else

17193


17194
        {

17195
          LeadLagFilter_sf(childS);

17196
          sfcnInitializeSizes(childS);

17197
        }

17198


17199
#endif

17200


17201
        sfcnInitializeSampleTimes(childS);

17202


17203
        /* adjust sample time */

17204
        ssSetSampleTime(childS, 0, 0.0);

17205
        ssSetOffsetTime(childS, 0, 0.0);

17206
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

17207


17208
        /* set compiled values of dynamic vector attributes */

17209
        ssSetNumNonsampledZCs(childS, 0);

17210


17211
        /* Update connectivity flags for each port */

17212
        _ssSetInputPortConnected(childS, 0, 1);

17213
        _ssSetInputPortConnected(childS, 1, 1);

17214
        _ssSetInputPortConnected(childS, 2, 1);

17215
        _ssSetInputPortConnected(childS, 3, 1);

17216
        _ssSetInputPortConnected(childS, 4, 1);

17217
        _ssSetInputPortConnected(childS, 5, 1);

17218
        _ssSetInputPortConnected(childS, 6, 1);

17219
        _ssSetOutputPortConnected(childS, 0, 1);

17220
        _ssSetOutputPortBeingMerged(childS, 0, 0);

17221


17222
        /* Update the BufferDstPort flags for each input port */

17223
        _ssSetInputPortBufferDstPort(childS, 0, -1);

17224
        _ssSetInputPortBufferDstPort(childS, 1, -1);

17225
        _ssSetInputPortBufferDstPort(childS, 2, -1);

17226
        _ssSetInputPortBufferDstPort(childS, 3, -1);

17227
        _ssSetInputPortBufferDstPort(childS, 4, -1);

17228
        _ssSetInputPortBufferDstPort(childS, 5, -1);

17229
        _ssSetInputPortBufferDstPort(childS, 6, -1);

17230
      }

17231


17232
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S128>/Generated S-Function1 (Res180_sf) */

17233
      {

17234
        SimStruct *childS = ssGetSFunction(rts, 64);

17235


17236
        /* timing info */

17237
        time_T *sfcnPeriod;

17238
        time_T *sfcnOffset;

17239
        int_T *sfcnTsMap;

17240
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

17241
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

17242
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

17243
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

17244
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

17245
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

17246
        (void) memset((void*)sfcnPeriod, 0,

17247
                      sizeof(time_T)*1);

17248
        (void) memset((void*)sfcnOffset, 0,

17249
                      sizeof(time_T)*1);

17250
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

17251
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

17252
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

17253


17254
        /* Set up the mdlInfo pointer */

17255
# ifdef USE_RTMODEL

17256


17257
        {

17258
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

17259
              struct _ssBlkInfo2));

17260
          ss_VALIDATE_MEMORY(rts,blkInfo2);

17261
          ssSetBlkInfo2Ptr(childS, blkInfo2);

17262
        }

17263


17264
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

17265


17266
# else

17267


17268
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

17269


17270
# endif                                /* USE_RTMODEL */

17271


17272
        /* Allocate memory of model methods 2 */

17273
        {

17274
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

17275
            malloc(sizeof(struct _ssSFcnModelMethods2));

17276
          ss_VALIDATE_MEMORY(rts,methods2);

17277
          ssSetModelMethods2(childS, methods2);

17278
        }

17279


17280
        /* Allocate memory of model methods 3 */

17281
        {

17282
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

17283
            malloc(sizeof(struct _ssSFcnModelMethods3));

17284
          ss_VALIDATE_MEMORY(rts,methods3);

17285
          ssSetModelMethods3(childS, methods3);

17286
        }

17287


17288
        /* Allocate memory for states auxilliary information */

17289
        {

17290
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

17291
            (sizeof(struct _ssStatesInfo2));

17292
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

17293
            malloc(sizeof(ssPeriodicStatesInfo));

17294
          ss_VALIDATE_MEMORY(rts,statesInfo2);

17295
          ssSetStatesInfo2(childS, statesInfo2);

17296
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

17297
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

17298
        }

17299


17300
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

17301
          RegNumInputPorts);

17302
        ssSetRegNumInputPortsFcnArg(childS,childS);

17303


17304
        /* inputs */

17305
        {

17306
          struct _ssPortInputs *inputPortInfo =

17307
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

17308
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

17309
          _ssSetNumInputPorts(childS, 1);

17310
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

17311


17312
          /* port 0 */

17313
          {

17314
            real32_T const **sfcnUPtrs = (real32_T const **)

17315
              malloc(1 * sizeof(real32_T *));

17316
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17317
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

17318
              ssGetLocalBlockIO(rts))->Sum1_g;

17319
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

17320
            _ssSetInputPortNumDimensions(childS, 0, 1);

17321
            ssSetInputPortWidth(childS, 0, 1);

17322
          }

17323
        }

17324


17325
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

17326
          RegNumOutputPorts);

17327
        ssSetRegNumOutputPortsFcnArg(childS,childS);

17328


17329
        /* outputs */

17330
        {

17331
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

17332
            calloc(1, sizeof(struct _ssPortOutputs));

17333
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

17334
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

17335
          _ssSetNumOutputPorts(childS, 1);

17336


17337
          /* port 0 */

17338
          {

17339
            _ssSetOutputPortNumDimensions(childS, 0, 1);

17340
            ssSetOutputPortWidth(childS, 0, 1);

17341
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

17342
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_hp));

17343
          }

17344
        }

17345


17346
        /* path info */

17347
        _ssSetModelName(childS, "Res180_sf");

17348
        _ssSetPath(childS,

17349
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Generated S-Function1");

17350
        if (ssGetRTModel(rts) == (NULL)) {

17351
          _ssSetParentSS(childS, rts);

17352
          _ssSetRootSS(childS, ssGetRootSS(rts));

17353
        } else {

17354
          ssSetRTModel(childS,ssGetRTModel(rts));

17355
          _ssSetParentSS(childS, (NULL));

17356
          _ssSetRootSS(childS, childS);

17357
        }

17358


17359
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

17360
        (childS)->regDataType.arg1 = ((void *)(childS));

17361
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

17362
          FcnSetErrorStatus);

17363
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

17364
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

17365
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

17366
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

17367


17368
        /* registration */

17369
#if defined(MATLAB_MEX_FILE)

17370


17371
        {

17372
          int_T i;

17373
          mxArray *plhs[1];

17374
          mxArray *prhs[4];

17375
          double *pr;

17376
          volatile int_T *intS = (int_T *)&childS;

17377
          int_T addrlen = sizeof(SimStruct *);

17378
          int_T m = addrlen/sizeof(int_T) + 1;

17379
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

17380
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

17381
          pr = mxGetPr(prhs[1]);

17382
          for (i = 0; i < m - 1; i++) {

17383
            pr[i] = (double)intS[i];

17384
          }

17385


17386
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

17387
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

17388
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

17389


17390
          /* Reset port dimensions info functions because the S-function

17391
           * and accelerator mex-files explicitly set their dimensions,

17392
           * i.e., they are not dynamically sized. For this case, the

17393
           * mex-file is responsible for the dimensions info memory

17394
           * and Simulink should not free it. This is achieved by

17395
           * setting the following two methods to NULL.

17396
           */

17397
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

17398
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

17399


17400
          /*

17401
           * Setup function pointers and call mdlInitializeSizes via

17402
           * simulink.c

17403
           */

17404
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

17405
          mxDestroyArray(plhs[0]);

17406
          mxDestroyArray(prhs[0]);

17407
          mxDestroyArray(prhs[1]);

17408
          mxDestroyArray(prhs[2]);

17409
          mxDestroyArray(prhs[3]);

17410
        }

17411


17412
#else

17413


17414
        {

17415
          Res180_sf(childS);

17416
          sfcnInitializeSizes(childS);

17417
        }

17418


17419
#endif

17420


17421
        sfcnInitializeSampleTimes(childS);

17422


17423
        /* adjust sample time */

17424
        ssSetSampleTime(childS, 0, 0.0);

17425
        ssSetOffsetTime(childS, 0, 0.0);

17426
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

17427


17428
        /* set compiled values of dynamic vector attributes */

17429
        ssSetNumNonsampledZCs(childS, 0);

17430


17431
        /* Update connectivity flags for each port */

17432
        _ssSetInputPortConnected(childS, 0, 1);

17433
        _ssSetOutputPortConnected(childS, 0, 1);

17434
        _ssSetOutputPortBeingMerged(childS, 0, 0);

17435


17436
        /* Update the BufferDstPort flags for each input port */

17437
        _ssSetInputPortBufferDstPort(childS, 0, -1);

17438
      }

17439


17440
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S153>/Generated S-Function1 (SaturationLimiter_sf) */

17441
      {

17442
        SimStruct *childS = ssGetSFunction(rts, 65);

17443


17444
        /* timing info */

17445
        time_T *sfcnPeriod;

17446
        time_T *sfcnOffset;

17447
        int_T *sfcnTsMap;

17448
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

17449
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

17450
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

17451
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

17452
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

17453
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

17454
        (void) memset((void*)sfcnPeriod, 0,

17455
                      sizeof(time_T)*1);

17456
        (void) memset((void*)sfcnOffset, 0,

17457
                      sizeof(time_T)*1);

17458
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

17459
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

17460
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

17461


17462
        /* Set up the mdlInfo pointer */

17463
# ifdef USE_RTMODEL

17464


17465
        {

17466
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

17467
              struct _ssBlkInfo2));

17468
          ss_VALIDATE_MEMORY(rts,blkInfo2);

17469
          ssSetBlkInfo2Ptr(childS, blkInfo2);

17470
        }

17471


17472
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

17473


17474
# else

17475


17476
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

17477


17478
# endif                                /* USE_RTMODEL */

17479


17480
        /* Allocate memory of model methods 2 */

17481
        {

17482
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

17483
            malloc(sizeof(struct _ssSFcnModelMethods2));

17484
          ss_VALIDATE_MEMORY(rts,methods2);

17485
          ssSetModelMethods2(childS, methods2);

17486
        }

17487


17488
        /* Allocate memory of model methods 3 */

17489
        {

17490
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

17491
            malloc(sizeof(struct _ssSFcnModelMethods3));

17492
          ss_VALIDATE_MEMORY(rts,methods3);

17493
          ssSetModelMethods3(childS, methods3);

17494
        }

17495


17496
        /* Allocate memory for states auxilliary information */

17497
        {

17498
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

17499
            (sizeof(struct _ssStatesInfo2));

17500
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

17501
            malloc(sizeof(ssPeriodicStatesInfo));

17502
          ss_VALIDATE_MEMORY(rts,statesInfo2);

17503
          ssSetStatesInfo2(childS, statesInfo2);

17504
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

17505
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

17506
        }

17507


17508
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

17509
          RegNumInputPorts);

17510
        ssSetRegNumInputPortsFcnArg(childS,childS);

17511


17512
        /* inputs */

17513
        {

17514
          struct _ssPortInputs *inputPortInfo =

17515
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

17516
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

17517
          _ssSetNumInputPorts(childS, 3);

17518
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

17519


17520
          /* port 0 */

17521
          {

17522
            real32_T const **sfcnUPtrs = (real32_T const **)

17523
              malloc(1 * sizeof(real32_T *));

17524
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17525
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

17526
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_hp;

17527
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

17528
            _ssSetInputPortNumDimensions(childS, 0, 1);

17529
            ssSetInputPortWidth(childS, 0, 1);

17530
          }

17531


17532
          /* port 1 */

17533
          {

17534
            real32_T const **sfcnUPtrs = (real32_T const **)

17535
              malloc(1 * sizeof(real32_T *));

17536
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17537
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

17538
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

17539
            _ssSetInputPortNumDimensions(childS, 1, 1);

17540
            ssSetInputPortWidth(childS, 1, 1);

17541
          }

17542


17543
          /* port 2 */

17544
          {

17545
            real32_T const **sfcnUPtrs = (real32_T const **)

17546
              malloc(1 * sizeof(real32_T *));

17547
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17548
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

17549
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

17550
            _ssSetInputPortNumDimensions(childS, 2, 1);

17551
            ssSetInputPortWidth(childS, 2, 1);

17552
          }

17553
        }

17554


17555
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

17556
          RegNumOutputPorts);

17557
        ssSetRegNumOutputPortsFcnArg(childS,childS);

17558


17559
        /* outputs */

17560
        {

17561
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

17562
            calloc(1, sizeof(struct _ssPortOutputs));

17563
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

17564
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

17565
          _ssSetNumOutputPorts(childS, 1);

17566


17567
          /* port 0 */

17568
          {

17569
            _ssSetOutputPortNumDimensions(childS, 0, 1);

17570
            ssSetOutputPortWidth(childS, 0, 1);

17571
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

17572
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_oq));

17573
          }

17574
        }

17575


17576
        /* path info */

17577
        _ssSetModelName(childS, "SaturationLimiter_sf");

17578
        _ssSetPath(childS,

17579
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Saturation Limiter/Generated S-Function1");

17580
        if (ssGetRTModel(rts) == (NULL)) {

17581
          _ssSetParentSS(childS, rts);

17582
          _ssSetRootSS(childS, ssGetRootSS(rts));

17583
        } else {

17584
          ssSetRTModel(childS,ssGetRTModel(rts));

17585
          _ssSetParentSS(childS, (NULL));

17586
          _ssSetRootSS(childS, childS);

17587
        }

17588


17589
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

17590
        (childS)->regDataType.arg1 = ((void *)(childS));

17591
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

17592
          FcnSetErrorStatus);

17593
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

17594
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

17595
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

17596
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

17597


17598
        /* registration */

17599
#if defined(MATLAB_MEX_FILE)

17600


17601
        {

17602
          int_T i;

17603
          mxArray *plhs[1];

17604
          mxArray *prhs[4];

17605
          double *pr;

17606
          volatile int_T *intS = (int_T *)&childS;

17607
          int_T addrlen = sizeof(SimStruct *);

17608
          int_T m = addrlen/sizeof(int_T) + 1;

17609
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

17610
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

17611
          pr = mxGetPr(prhs[1]);

17612
          for (i = 0; i < m - 1; i++) {

17613
            pr[i] = (double)intS[i];

17614
          }

17615


17616
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

17617
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

17618
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

17619


17620
          /* Reset port dimensions info functions because the S-function

17621
           * and accelerator mex-files explicitly set their dimensions,

17622
           * i.e., they are not dynamically sized. For this case, the

17623
           * mex-file is responsible for the dimensions info memory

17624
           * and Simulink should not free it. This is achieved by

17625
           * setting the following two methods to NULL.

17626
           */

17627
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

17628
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

17629


17630
          /*

17631
           * Setup function pointers and call mdlInitializeSizes via

17632
           * simulink.c

17633
           */

17634
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

17635
          mxDestroyArray(plhs[0]);

17636
          mxDestroyArray(prhs[0]);

17637
          mxDestroyArray(prhs[1]);

17638
          mxDestroyArray(prhs[2]);

17639
          mxDestroyArray(prhs[3]);

17640
        }

17641


17642
#else

17643


17644
        {

17645
          SaturationLimiter_sf(childS);

17646
          sfcnInitializeSizes(childS);

17647
        }

17648


17649
#endif

17650


17651
        sfcnInitializeSampleTimes(childS);

17652


17653
        /* adjust sample time */

17654
        ssSetSampleTime(childS, 0, 0.0);

17655
        ssSetOffsetTime(childS, 0, 0.0);

17656
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

17657


17658
        /* set compiled values of dynamic vector attributes */

17659
        ssSetNumNonsampledZCs(childS, 0);

17660


17661
        /* Update connectivity flags for each port */

17662
        _ssSetInputPortConnected(childS, 0, 1);

17663
        _ssSetInputPortConnected(childS, 1, 1);

17664
        _ssSetInputPortConnected(childS, 2, 1);

17665
        _ssSetOutputPortConnected(childS, 0, 1);

17666
        _ssSetOutputPortBeingMerged(childS, 0, 0);

17667


17668
        /* Update the BufferDstPort flags for each input port */

17669
        _ssSetInputPortBufferDstPort(childS, 0, -1);

17670
        _ssSetInputPortBufferDstPort(childS, 1, -1);

17671
        _ssSetInputPortBufferDstPort(childS, 2, -1);

17672
      }

17673


17674
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S156>/Generated S-Function (Gain_sf) */

17675
      {

17676
        SimStruct *childS = ssGetSFunction(rts, 66);

17677


17678
        /* timing info */

17679
        time_T *sfcnPeriod;

17680
        time_T *sfcnOffset;

17681
        int_T *sfcnTsMap;

17682
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

17683
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

17684
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

17685
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

17686
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

17687
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

17688
        (void) memset((void*)sfcnPeriod, 0,

17689
                      sizeof(time_T)*1);

17690
        (void) memset((void*)sfcnOffset, 0,

17691
                      sizeof(time_T)*1);

17692
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

17693
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

17694
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

17695


17696
        /* Set up the mdlInfo pointer */

17697
# ifdef USE_RTMODEL

17698


17699
        {

17700
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

17701
              struct _ssBlkInfo2));

17702
          ss_VALIDATE_MEMORY(rts,blkInfo2);

17703
          ssSetBlkInfo2Ptr(childS, blkInfo2);

17704
        }

17705


17706
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

17707


17708
# else

17709


17710
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

17711


17712
# endif                                /* USE_RTMODEL */

17713


17714
        /* Allocate memory of model methods 2 */

17715
        {

17716
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

17717
            malloc(sizeof(struct _ssSFcnModelMethods2));

17718
          ss_VALIDATE_MEMORY(rts,methods2);

17719
          ssSetModelMethods2(childS, methods2);

17720
        }

17721


17722
        /* Allocate memory of model methods 3 */

17723
        {

17724
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

17725
            malloc(sizeof(struct _ssSFcnModelMethods3));

17726
          ss_VALIDATE_MEMORY(rts,methods3);

17727
          ssSetModelMethods3(childS, methods3);

17728
        }

17729


17730
        /* Allocate memory for states auxilliary information */

17731
        {

17732
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

17733
            (sizeof(struct _ssStatesInfo2));

17734
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

17735
            malloc(sizeof(ssPeriodicStatesInfo));

17736
          ss_VALIDATE_MEMORY(rts,statesInfo2);

17737
          ssSetStatesInfo2(childS, statesInfo2);

17738
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

17739
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

17740
        }

17741


17742
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

17743
          RegNumInputPorts);

17744
        ssSetRegNumInputPortsFcnArg(childS,childS);

17745


17746
        /* inputs */

17747
        {

17748
          struct _ssPortInputs *inputPortInfo =

17749
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

17750
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

17751
          _ssSetNumInputPorts(childS, 2);

17752
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

17753


17754
          /* port 0 */

17755
          {

17756
            real32_T const **sfcnUPtrs = (real32_T const **)

17757
              malloc(1 * sizeof(real32_T *));

17758
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17759
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

17760
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_oq;

17761
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

17762
            _ssSetInputPortNumDimensions(childS, 0, 1);

17763
            ssSetInputPortWidth(childS, 0, 1);

17764
          }

17765


17766
          /* port 1 */

17767
          {

17768
            real32_T const **sfcnUPtrs = (real32_T const **)

17769
              malloc(1 * sizeof(real32_T *));

17770
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17771
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

17772
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

17773
            _ssSetInputPortNumDimensions(childS, 1, 1);

17774
            ssSetInputPortWidth(childS, 1, 1);

17775
          }

17776
        }

17777


17778
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

17779
          RegNumOutputPorts);

17780
        ssSetRegNumOutputPortsFcnArg(childS,childS);

17781


17782
        /* outputs */

17783
        {

17784
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

17785
            calloc(1, sizeof(struct _ssPortOutputs));

17786
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

17787
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

17788
          _ssSetNumOutputPorts(childS, 1);

17789


17790
          /* port 0 */

17791
          {

17792
            _ssSetOutputPortNumDimensions(childS, 0, 1);

17793
            ssSetOutputPortWidth(childS, 0, 1);

17794
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

17795
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ex));

17796
          }

17797
        }

17798


17799
        /* path info */

17800
        _ssSetModelName(childS, "Gain_sf");

17801
        _ssSetPath(childS,

17802
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/gain/Generated S-Function");

17803
        if (ssGetRTModel(rts) == (NULL)) {

17804
          _ssSetParentSS(childS, rts);

17805
          _ssSetRootSS(childS, ssGetRootSS(rts));

17806
        } else {

17807
          ssSetRTModel(childS,ssGetRTModel(rts));

17808
          _ssSetParentSS(childS, (NULL));

17809
          _ssSetRootSS(childS, childS);

17810
        }

17811


17812
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

17813
        (childS)->regDataType.arg1 = ((void *)(childS));

17814
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

17815
          FcnSetErrorStatus);

17816
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

17817
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

17818
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

17819
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

17820


17821
        /* registration */

17822
#if defined(MATLAB_MEX_FILE)

17823


17824
        {

17825
          int_T i;

17826
          mxArray *plhs[1];

17827
          mxArray *prhs[4];

17828
          double *pr;

17829
          volatile int_T *intS = (int_T *)&childS;

17830
          int_T addrlen = sizeof(SimStruct *);

17831
          int_T m = addrlen/sizeof(int_T) + 1;

17832
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

17833
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

17834
          pr = mxGetPr(prhs[1]);

17835
          for (i = 0; i < m - 1; i++) {

17836
            pr[i] = (double)intS[i];

17837
          }

17838


17839
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

17840
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

17841
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

17842


17843
          /* Reset port dimensions info functions because the S-function

17844
           * and accelerator mex-files explicitly set their dimensions,

17845
           * i.e., they are not dynamically sized. For this case, the

17846
           * mex-file is responsible for the dimensions info memory

17847
           * and Simulink should not free it. This is achieved by

17848
           * setting the following two methods to NULL.

17849
           */

17850
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

17851
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

17852


17853
          /*

17854
           * Setup function pointers and call mdlInitializeSizes via

17855
           * simulink.c

17856
           */

17857
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

17858
          mxDestroyArray(plhs[0]);

17859
          mxDestroyArray(prhs[0]);

17860
          mxDestroyArray(prhs[1]);

17861
          mxDestroyArray(prhs[2]);

17862
          mxDestroyArray(prhs[3]);

17863
        }

17864


17865
#else

17866


17867
        {

17868
          Gain_sf(childS);

17869
          sfcnInitializeSizes(childS);

17870
        }

17871


17872
#endif

17873


17874
        sfcnInitializeSampleTimes(childS);

17875


17876
        /* adjust sample time */

17877
        ssSetSampleTime(childS, 0, 0.0);

17878
        ssSetOffsetTime(childS, 0, 0.0);

17879
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

17880


17881
        /* set compiled values of dynamic vector attributes */

17882
        ssSetNumNonsampledZCs(childS, 0);

17883


17884
        /* Update connectivity flags for each port */

17885
        _ssSetInputPortConnected(childS, 0, 1);

17886
        _ssSetInputPortConnected(childS, 1, 1);

17887
        _ssSetOutputPortConnected(childS, 0, 1);

17888
        _ssSetOutputPortBeingMerged(childS, 0, 0);

17889


17890
        /* Update the BufferDstPort flags for each input port */

17891
        _ssSetInputPortBufferDstPort(childS, 0, -1);

17892
        _ssSetInputPortBufferDstPort(childS, 1, -1);

17893
      }

17894


17895
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S157>/Generated S-Function (Gain_sf) */

17896
      {

17897
        SimStruct *childS = ssGetSFunction(rts, 67);

17898


17899
        /* timing info */

17900
        time_T *sfcnPeriod;

17901
        time_T *sfcnOffset;

17902
        int_T *sfcnTsMap;

17903
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

17904
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

17905
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

17906
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

17907
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

17908
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

17909
        (void) memset((void*)sfcnPeriod, 0,

17910
                      sizeof(time_T)*1);

17911
        (void) memset((void*)sfcnOffset, 0,

17912
                      sizeof(time_T)*1);

17913
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

17914
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

17915
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

17916


17917
        /* Set up the mdlInfo pointer */

17918
# ifdef USE_RTMODEL

17919


17920
        {

17921
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

17922
              struct _ssBlkInfo2));

17923
          ss_VALIDATE_MEMORY(rts,blkInfo2);

17924
          ssSetBlkInfo2Ptr(childS, blkInfo2);

17925
        }

17926


17927
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

17928


17929
# else

17930


17931
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

17932


17933
# endif                                /* USE_RTMODEL */

17934


17935
        /* Allocate memory of model methods 2 */

17936
        {

17937
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

17938
            malloc(sizeof(struct _ssSFcnModelMethods2));

17939
          ss_VALIDATE_MEMORY(rts,methods2);

17940
          ssSetModelMethods2(childS, methods2);

17941
        }

17942


17943
        /* Allocate memory of model methods 3 */

17944
        {

17945
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

17946
            malloc(sizeof(struct _ssSFcnModelMethods3));

17947
          ss_VALIDATE_MEMORY(rts,methods3);

17948
          ssSetModelMethods3(childS, methods3);

17949
        }

17950


17951
        /* Allocate memory for states auxilliary information */

17952
        {

17953
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

17954
            (sizeof(struct _ssStatesInfo2));

17955
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

17956
            malloc(sizeof(ssPeriodicStatesInfo));

17957
          ss_VALIDATE_MEMORY(rts,statesInfo2);

17958
          ssSetStatesInfo2(childS, statesInfo2);

17959
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

17960
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

17961
        }

17962


17963
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

17964
          RegNumInputPorts);

17965
        ssSetRegNumInputPortsFcnArg(childS,childS);

17966


17967
        /* inputs */

17968
        {

17969
          struct _ssPortInputs *inputPortInfo =

17970
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

17971
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

17972
          _ssSetNumInputPorts(childS, 2);

17973
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

17974


17975
          /* port 0 */

17976
          {

17977
            real32_T const **sfcnUPtrs = (real32_T const **)

17978
              malloc(1 * sizeof(real32_T *));

17979
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17980
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

17981
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ex;

17982
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

17983
            _ssSetInputPortNumDimensions(childS, 0, 1);

17984
            ssSetInputPortWidth(childS, 0, 1);

17985
          }

17986


17987
          /* port 1 */

17988
          {

17989
            real32_T const **sfcnUPtrs = (real32_T const **)

17990
              malloc(1 * sizeof(real32_T *));

17991
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

17992
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

17993
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

17994
            _ssSetInputPortNumDimensions(childS, 1, 1);

17995
            ssSetInputPortWidth(childS, 1, 1);

17996
          }

17997
        }

17998


17999
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

18000
          RegNumOutputPorts);

18001
        ssSetRegNumOutputPortsFcnArg(childS,childS);

18002


18003
        /* outputs */

18004
        {

18005
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

18006
            calloc(1, sizeof(struct _ssPortOutputs));

18007
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

18008
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

18009
          _ssSetNumOutputPorts(childS, 1);

18010


18011
          /* port 0 */

18012
          {

18013
            _ssSetOutputPortNumDimensions(childS, 0, 1);

18014
            ssSetOutputPortWidth(childS, 0, 1);

18015
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

18016
              ssGetLocalBlockIO(rts))->GeneratedSFunction_nh));

18017
          }

18018
        }

18019


18020
        /* path info */

18021
        _ssSetModelName(childS, "Gain_sf");

18022
        _ssSetPath(childS,

18023
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/gain1/Generated S-Function");

18024
        if (ssGetRTModel(rts) == (NULL)) {

18025
          _ssSetParentSS(childS, rts);

18026
          _ssSetRootSS(childS, ssGetRootSS(rts));

18027
        } else {

18028
          ssSetRTModel(childS,ssGetRTModel(rts));

18029
          _ssSetParentSS(childS, (NULL));

18030
          _ssSetRootSS(childS, childS);

18031
        }

18032


18033
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

18034
        (childS)->regDataType.arg1 = ((void *)(childS));

18035
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

18036
          FcnSetErrorStatus);

18037
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

18038
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

18039
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

18040
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

18041


18042
        /* registration */

18043
#if defined(MATLAB_MEX_FILE)

18044


18045
        {

18046
          int_T i;

18047
          mxArray *plhs[1];

18048
          mxArray *prhs[4];

18049
          double *pr;

18050
          volatile int_T *intS = (int_T *)&childS;

18051
          int_T addrlen = sizeof(SimStruct *);

18052
          int_T m = addrlen/sizeof(int_T) + 1;

18053
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

18054
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

18055
          pr = mxGetPr(prhs[1]);

18056
          for (i = 0; i < m - 1; i++) {

18057
            pr[i] = (double)intS[i];

18058
          }

18059


18060
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

18061
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

18062
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

18063


18064
          /* Reset port dimensions info functions because the S-function

18065
           * and accelerator mex-files explicitly set their dimensions,

18066
           * i.e., they are not dynamically sized. For this case, the

18067
           * mex-file is responsible for the dimensions info memory

18068
           * and Simulink should not free it. This is achieved by

18069
           * setting the following two methods to NULL.

18070
           */

18071
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

18072
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

18073


18074
          /*

18075
           * Setup function pointers and call mdlInitializeSizes via

18076
           * simulink.c

18077
           */

18078
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

18079
          mxDestroyArray(plhs[0]);

18080
          mxDestroyArray(prhs[0]);

18081
          mxDestroyArray(prhs[1]);

18082
          mxDestroyArray(prhs[2]);

18083
          mxDestroyArray(prhs[3]);

18084
        }

18085


18086
#else

18087


18088
        {

18089
          Gain_sf(childS);

18090
          sfcnInitializeSizes(childS);

18091
        }

18092


18093
#endif

18094


18095
        sfcnInitializeSampleTimes(childS);

18096


18097
        /* adjust sample time */

18098
        ssSetSampleTime(childS, 0, 0.0);

18099
        ssSetOffsetTime(childS, 0, 0.0);

18100
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

18101


18102
        /* set compiled values of dynamic vector attributes */

18103
        ssSetNumNonsampledZCs(childS, 0);

18104


18105
        /* Update connectivity flags for each port */

18106
        _ssSetInputPortConnected(childS, 0, 1);

18107
        _ssSetInputPortConnected(childS, 1, 1);

18108
        _ssSetOutputPortConnected(childS, 0, 1);

18109
        _ssSetOutputPortBeingMerged(childS, 0, 0);

18110


18111
        /* Update the BufferDstPort flags for each input port */

18112
        _ssSetInputPortBufferDstPort(childS, 0, -1);

18113
        _ssSetInputPortBufferDstPort(childS, 1, -1);

18114
      }

18115


18116
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S150>/Generated S-Function3 (IntegratorLimited_sf) */

18117
      {

18118
        SimStruct *childS = ssGetSFunction(rts, 68);

18119


18120
        /* timing info */

18121
        time_T *sfcnPeriod;

18122
        time_T *sfcnOffset;

18123
        int_T *sfcnTsMap;

18124
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

18125
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

18126
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

18127
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

18128
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

18129
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

18130
        (void) memset((void*)sfcnPeriod, 0,

18131
                      sizeof(time_T)*1);

18132
        (void) memset((void*)sfcnOffset, 0,

18133
                      sizeof(time_T)*1);

18134
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

18135
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

18136
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

18137


18138
        /* Set up the mdlInfo pointer */

18139
# ifdef USE_RTMODEL

18140


18141
        {

18142
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

18143
              struct _ssBlkInfo2));

18144
          ss_VALIDATE_MEMORY(rts,blkInfo2);

18145
          ssSetBlkInfo2Ptr(childS, blkInfo2);

18146
        }

18147


18148
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

18149


18150
# else

18151


18152
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

18153


18154
# endif                                /* USE_RTMODEL */

18155


18156
        /* Allocate memory of model methods 2 */

18157
        {

18158
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

18159
            malloc(sizeof(struct _ssSFcnModelMethods2));

18160
          ss_VALIDATE_MEMORY(rts,methods2);

18161
          ssSetModelMethods2(childS, methods2);

18162
        }

18163


18164
        /* Allocate memory of model methods 3 */

18165
        {

18166
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

18167
            malloc(sizeof(struct _ssSFcnModelMethods3));

18168
          ss_VALIDATE_MEMORY(rts,methods3);

18169
          ssSetModelMethods3(childS, methods3);

18170
        }

18171


18172
        /* Allocate memory for states auxilliary information */

18173
        {

18174
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

18175
            (sizeof(struct _ssStatesInfo2));

18176
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

18177
            malloc(sizeof(ssPeriodicStatesInfo));

18178
          ss_VALIDATE_MEMORY(rts,statesInfo2);

18179
          ssSetStatesInfo2(childS, statesInfo2);

18180
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

18181
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

18182
        }

18183


18184
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

18185
          RegNumInputPorts);

18186
        ssSetRegNumInputPortsFcnArg(childS,childS);

18187


18188
        /* inputs */

18189
        {

18190
          struct _ssPortInputs *inputPortInfo =

18191
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

18192
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

18193
          _ssSetNumInputPorts(childS, 7);

18194
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

18195


18196
          /* port 0 */

18197
          {

18198
            real32_T const **sfcnUPtrs = (real32_T const **)

18199
              malloc(1 * sizeof(real32_T *));

18200
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18201
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18202
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

18203
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

18204
            _ssSetInputPortNumDimensions(childS, 0, 1);

18205
            ssSetInputPortWidth(childS, 0, 1);

18206
          }

18207


18208
          /* port 1 */

18209
          {

18210
            int8_T const **sfcnUPtrs = (int8_T const **)

18211
              malloc(1 * sizeof(int8_T *));

18212
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18213
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

18214
              ssGetLocalBlockIO(rts))->DataTypeConversion1_h;

18215
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

18216
            _ssSetInputPortNumDimensions(childS, 1, 1);

18217
            ssSetInputPortWidth(childS, 1, 1);

18218
          }

18219


18220
          /* port 2 */

18221
          {

18222
            real32_T const **sfcnUPtrs = (real32_T const **)

18223
              malloc(1 * sizeof(real32_T *));

18224
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18225
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

18226
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

18227
            _ssSetInputPortNumDimensions(childS, 2, 1);

18228
            ssSetInputPortWidth(childS, 2, 1);

18229
          }

18230


18231
          /* port 3 */

18232
          {

18233
            real32_T const **sfcnUPtrs = (real32_T const **)

18234
              malloc(1 * sizeof(real32_T *));

18235
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18236
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

18237
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

18238
            _ssSetInputPortNumDimensions(childS, 3, 1);

18239
            ssSetInputPortWidth(childS, 3, 1);

18240
          }

18241


18242
          /* port 4 */

18243
          {

18244
            real32_T const **sfcnUPtrs = (real32_T const **)

18245
              malloc(1 * sizeof(real32_T *));

18246
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18247
            sfcnUPtrs[0] = (real32_T const *)

18248
              &AFCS_MODEL1_ConstP.Constant29_Value;

18249
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

18250
            _ssSetInputPortNumDimensions(childS, 4, 1);

18251
            ssSetInputPortWidth(childS, 4, 1);

18252
          }

18253


18254
          /* port 5 */

18255
          {

18256
            real32_T const **sfcnUPtrs = (real32_T const **)

18257
              malloc(1 * sizeof(real32_T *));

18258
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18259
            sfcnUPtrs[0] = (real32_T const *)

18260
              &AFCS_MODEL1_ConstP.Constant30_Value;

18261
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

18262
            _ssSetInputPortNumDimensions(childS, 5, 1);

18263
            ssSetInputPortWidth(childS, 5, 1);

18264
          }

18265


18266
          /* port 6 */

18267
          {

18268
            real32_T const **sfcnUPtrs = (real32_T const **)

18269
              malloc(1 * sizeof(real32_T *));

18270
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18271
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18272
              ssGetLocalBlockIO(rts))->GeneratedSFunction_nh;

18273
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

18274
            _ssSetInputPortNumDimensions(childS, 6, 1);

18275
            ssSetInputPortWidth(childS, 6, 1);

18276
          }

18277
        }

18278


18279
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

18280
          RegNumOutputPorts);

18281
        ssSetRegNumOutputPortsFcnArg(childS,childS);

18282


18283
        /* outputs */

18284
        {

18285
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

18286
            calloc(1, sizeof(struct _ssPortOutputs));

18287
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

18288
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

18289
          _ssSetNumOutputPorts(childS, 1);

18290


18291
          /* port 0 */

18292
          {

18293
            _ssSetOutputPortNumDimensions(childS, 0, 1);

18294
            ssSetOutputPortWidth(childS, 0, 1);

18295
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

18296
              ssGetLocalBlockIO(rts))->Saturation2_p));

18297
          }

18298
        }

18299


18300
        /* path info */

18301
        _ssSetModelName(childS, "IntegratorLimited_sf");

18302
        _ssSetPath(childS,

18303
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Integrator Limited/Generated S-Function3");

18304
        if (ssGetRTModel(rts) == (NULL)) {

18305
          _ssSetParentSS(childS, rts);

18306
          _ssSetRootSS(childS, ssGetRootSS(rts));

18307
        } else {

18308
          ssSetRTModel(childS,ssGetRTModel(rts));

18309
          _ssSetParentSS(childS, (NULL));

18310
          _ssSetRootSS(childS, childS);

18311
        }

18312


18313
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

18314


18315
        /* work vectors */

18316
        {

18317
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

18318
            (4 * sizeof(struct _ssDWorkRecord));

18319
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

18320
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

18321
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

18322
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

18323
          ssSetSFcnDWork(childS, dWorkRecord);

18324
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

18325
          _ssSetNumDWork(childS, 4);

18326


18327
          /* DWORK0 */

18328
          ssSetDWorkWidth(childS, 0, 1);

18329
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

18330
          ssSetDWorkComplexSignal(childS, 0, 0);

18331
          ssSetDWorkUsedAsDState(childS, 0, 1);

18332
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 200))[0]);

18333


18334
          /* DWORK1 */

18335
          ssSetDWorkWidth(childS, 1, 1);

18336
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

18337
          ssSetDWorkComplexSignal(childS, 1, 0);

18338
          ssSetDWorkUsedAsDState(childS, 1, 1);

18339
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 201))[0]);

18340


18341
          /* DWORK2 */

18342
          ssSetDWorkWidth(childS, 2, 1);

18343
          ssSetDWorkDataType(childS, 2,SS_INT8);

18344
          ssSetDWorkComplexSignal(childS, 2, 0);

18345
          ssSetDWorkUsedAsDState(childS, 2, 1);

18346
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 427))[0]);

18347


18348
          /* DWORK3 */

18349
          ssSetDWorkWidth(childS, 3, 1);

18350
          ssSetDWorkDataType(childS, 3,SS_INT8);

18351
          ssSetDWorkComplexSignal(childS, 3, 0);

18352
          ssSetDWorkUsedAsDState(childS, 3, 1);

18353
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 428))[0]);

18354
        }

18355


18356
        (childS)->regDataType.arg1 = ((void *)(childS));

18357
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

18358
          FcnSetErrorStatus);

18359
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

18360
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

18361
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

18362
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

18363


18364
        /* registration */

18365
#if defined(MATLAB_MEX_FILE)

18366


18367
        {

18368
          int_T i;

18369
          mxArray *plhs[1];

18370
          mxArray *prhs[4];

18371
          double *pr;

18372
          volatile int_T *intS = (int_T *)&childS;

18373
          int_T addrlen = sizeof(SimStruct *);

18374
          int_T m = addrlen/sizeof(int_T) + 1;

18375
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

18376
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

18377
          pr = mxGetPr(prhs[1]);

18378
          for (i = 0; i < m - 1; i++) {

18379
            pr[i] = (double)intS[i];

18380
          }

18381


18382
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

18383
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

18384
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

18385


18386
          /* Reset port dimensions info functions because the S-function

18387
           * and accelerator mex-files explicitly set their dimensions,

18388
           * i.e., they are not dynamically sized. For this case, the

18389
           * mex-file is responsible for the dimensions info memory

18390
           * and Simulink should not free it. This is achieved by

18391
           * setting the following two methods to NULL.

18392
           */

18393
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

18394
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

18395


18396
          /*

18397
           * Setup function pointers and call mdlInitializeSizes via

18398
           * simulink.c

18399
           */

18400
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

18401
          mxDestroyArray(plhs[0]);

18402
          mxDestroyArray(prhs[0]);

18403
          mxDestroyArray(prhs[1]);

18404
          mxDestroyArray(prhs[2]);

18405
          mxDestroyArray(prhs[3]);

18406
        }

18407


18408
#else

18409


18410
        {

18411
          IntegratorLimited_sf(childS);

18412
          sfcnInitializeSizes(childS);

18413
        }

18414


18415
#endif

18416


18417
        sfcnInitializeSampleTimes(childS);

18418


18419
        /* adjust sample time */

18420
        ssSetSampleTime(childS, 0, 0.0);

18421
        ssSetOffsetTime(childS, 0, 0.0);

18422
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

18423


18424
        /* set compiled values of dynamic vector attributes */

18425
        ssSetNumNonsampledZCs(childS, 0);

18426


18427
        /* Update connectivity flags for each port */

18428
        _ssSetInputPortConnected(childS, 0, 1);

18429
        _ssSetInputPortConnected(childS, 1, 1);

18430
        _ssSetInputPortConnected(childS, 2, 1);

18431
        _ssSetInputPortConnected(childS, 3, 1);

18432
        _ssSetInputPortConnected(childS, 4, 1);

18433
        _ssSetInputPortConnected(childS, 5, 1);

18434
        _ssSetInputPortConnected(childS, 6, 1);

18435
        _ssSetOutputPortConnected(childS, 0, 1);

18436
        _ssSetOutputPortBeingMerged(childS, 0, 0);

18437


18438
        /* Update the BufferDstPort flags for each input port */

18439
        _ssSetInputPortBufferDstPort(childS, 0, -1);

18440
        _ssSetInputPortBufferDstPort(childS, 1, -1);

18441
        _ssSetInputPortBufferDstPort(childS, 2, -1);

18442
        _ssSetInputPortBufferDstPort(childS, 3, -1);

18443
        _ssSetInputPortBufferDstPort(childS, 4, -1);

18444
        _ssSetInputPortBufferDstPort(childS, 5, -1);

18445
        _ssSetInputPortBufferDstPort(childS, 6, -1);

18446
      }

18447


18448
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S151>/Generated S-Function2 (LeadLagFilter_sf) */

18449
      {

18450
        SimStruct *childS = ssGetSFunction(rts, 69);

18451


18452
        /* timing info */

18453
        time_T *sfcnPeriod;

18454
        time_T *sfcnOffset;

18455
        int_T *sfcnTsMap;

18456
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

18457
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

18458
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

18459
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

18460
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

18461
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

18462
        (void) memset((void*)sfcnPeriod, 0,

18463
                      sizeof(time_T)*1);

18464
        (void) memset((void*)sfcnOffset, 0,

18465
                      sizeof(time_T)*1);

18466
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

18467
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

18468
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

18469


18470
        /* Set up the mdlInfo pointer */

18471
# ifdef USE_RTMODEL

18472


18473
        {

18474
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

18475
              struct _ssBlkInfo2));

18476
          ss_VALIDATE_MEMORY(rts,blkInfo2);

18477
          ssSetBlkInfo2Ptr(childS, blkInfo2);

18478
        }

18479


18480
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

18481


18482
# else

18483


18484
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

18485


18486
# endif                                /* USE_RTMODEL */

18487


18488
        /* Allocate memory of model methods 2 */

18489
        {

18490
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

18491
            malloc(sizeof(struct _ssSFcnModelMethods2));

18492
          ss_VALIDATE_MEMORY(rts,methods2);

18493
          ssSetModelMethods2(childS, methods2);

18494
        }

18495


18496
        /* Allocate memory of model methods 3 */

18497
        {

18498
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

18499
            malloc(sizeof(struct _ssSFcnModelMethods3));

18500
          ss_VALIDATE_MEMORY(rts,methods3);

18501
          ssSetModelMethods3(childS, methods3);

18502
        }

18503


18504
        /* Allocate memory for states auxilliary information */

18505
        {

18506
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

18507
            (sizeof(struct _ssStatesInfo2));

18508
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

18509
            malloc(sizeof(ssPeriodicStatesInfo));

18510
          ss_VALIDATE_MEMORY(rts,statesInfo2);

18511
          ssSetStatesInfo2(childS, statesInfo2);

18512
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

18513
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

18514
        }

18515


18516
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

18517
          RegNumInputPorts);

18518
        ssSetRegNumInputPortsFcnArg(childS,childS);

18519


18520
        /* inputs */

18521
        {

18522
          struct _ssPortInputs *inputPortInfo =

18523
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

18524
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

18525
          _ssSetNumInputPorts(childS, 7);

18526
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

18527


18528
          /* port 0 */

18529
          {

18530
            real32_T const **sfcnUPtrs = (real32_T const **)

18531
              malloc(1 * sizeof(real32_T *));

18532
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18533
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18534
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

18535
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

18536
            _ssSetInputPortNumDimensions(childS, 0, 1);

18537
            ssSetInputPortWidth(childS, 0, 1);

18538
          }

18539


18540
          /* port 1 */

18541
          {

18542
            int8_T const **sfcnUPtrs = (int8_T const **)

18543
              malloc(1 * sizeof(int8_T *));

18544
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18545
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

18546
              ssGetLocalBlockIO(rts))->DataTypeConversion1_h;

18547
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

18548
            _ssSetInputPortNumDimensions(childS, 1, 1);

18549
            ssSetInputPortWidth(childS, 1, 1);

18550
          }

18551


18552
          /* port 2 */

18553
          {

18554
            real32_T const **sfcnUPtrs = (real32_T const **)

18555
              malloc(1 * sizeof(real32_T *));

18556
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18557
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

18558
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

18559
            _ssSetInputPortNumDimensions(childS, 2, 1);

18560
            ssSetInputPortWidth(childS, 2, 1);

18561
          }

18562


18563
          /* port 3 */

18564
          {

18565
            real32_T const **sfcnUPtrs = (real32_T const **)

18566
              malloc(1 * sizeof(real32_T *));

18567
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18568
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

18569
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

18570
            _ssSetInputPortNumDimensions(childS, 3, 1);

18571
            ssSetInputPortWidth(childS, 3, 1);

18572
          }

18573


18574
          /* port 4 */

18575
          {

18576
            real32_T const **sfcnUPtrs = (real32_T const **)

18577
              malloc(1 * sizeof(real32_T *));

18578
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18579
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18580
              ssGetLocalBlockIO(rts))->Switch_bg;

18581
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

18582
            _ssSetInputPortNumDimensions(childS, 4, 1);

18583
            ssSetInputPortWidth(childS, 4, 1);

18584
          }

18585


18586
          /* port 5 */

18587
          {

18588
            real32_T const **sfcnUPtrs = (real32_T const **)

18589
              malloc(1 * sizeof(real32_T *));

18590
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18591
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18592
              ssGetLocalBlockIO(rts))->Switch_bg;

18593
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

18594
            _ssSetInputPortNumDimensions(childS, 5, 1);

18595
            ssSetInputPortWidth(childS, 5, 1);

18596
          }

18597


18598
          /* port 6 */

18599
          {

18600
            real32_T const **sfcnUPtrs = (real32_T const **)

18601
              malloc(1 * sizeof(real32_T *));

18602
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18603
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18604
              ssGetLocalBlockIO(rts))->Sum_d;

18605
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

18606
            _ssSetInputPortNumDimensions(childS, 6, 1);

18607
            ssSetInputPortWidth(childS, 6, 1);

18608
          }

18609
        }

18610


18611
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

18612
          RegNumOutputPorts);

18613
        ssSetRegNumOutputPortsFcnArg(childS,childS);

18614


18615
        /* outputs */

18616
        {

18617
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

18618
            calloc(1, sizeof(struct _ssPortOutputs));

18619
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

18620
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

18621
          _ssSetNumOutputPorts(childS, 1);

18622


18623
          /* port 0 */

18624
          {

18625
            _ssSetOutputPortNumDimensions(childS, 0, 1);

18626
            ssSetOutputPortWidth(childS, 0, 1);

18627
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

18628
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_i));

18629
          }

18630
        }

18631


18632
        /* path info */

18633
        _ssSetModelName(childS, "LeadLagFilter_sf");

18634
        _ssSetPath(childS,

18635
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Lead lag/Generated S-Function2");

18636
        if (ssGetRTModel(rts) == (NULL)) {

18637
          _ssSetParentSS(childS, rts);

18638
          _ssSetRootSS(childS, ssGetRootSS(rts));

18639
        } else {

18640
          ssSetRTModel(childS,ssGetRTModel(rts));

18641
          _ssSetParentSS(childS, (NULL));

18642
          _ssSetRootSS(childS, childS);

18643
        }

18644


18645
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

18646


18647
        /* work vectors */

18648
        {

18649
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

18650
            (4 * sizeof(struct _ssDWorkRecord));

18651
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

18652
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

18653
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

18654
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

18655
          ssSetSFcnDWork(childS, dWorkRecord);

18656
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

18657
          _ssSetNumDWork(childS, 4);

18658


18659
          /* DWORK0 */

18660
          ssSetDWorkWidth(childS, 0, 1);

18661
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

18662
          ssSetDWorkComplexSignal(childS, 0, 0);

18663
          ssSetDWorkUsedAsDState(childS, 0, 1);

18664
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 202))[0]);

18665


18666
          /* DWORK1 */

18667
          ssSetDWorkWidth(childS, 1, 1);

18668
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

18669
          ssSetDWorkComplexSignal(childS, 1, 0);

18670
          ssSetDWorkUsedAsDState(childS, 1, 1);

18671
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 203))[0]);

18672


18673
          /* DWORK2 */

18674
          ssSetDWorkWidth(childS, 2, 1);

18675
          ssSetDWorkDataType(childS, 2,SS_INT8);

18676
          ssSetDWorkComplexSignal(childS, 2, 0);

18677
          ssSetDWorkUsedAsDState(childS, 2, 1);

18678
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 429))[0]);

18679


18680
          /* DWORK3 */

18681
          ssSetDWorkWidth(childS, 3, 1);

18682
          ssSetDWorkDataType(childS, 3,SS_INT8);

18683
          ssSetDWorkComplexSignal(childS, 3, 0);

18684
          ssSetDWorkUsedAsDState(childS, 3, 1);

18685
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 430))[0]);

18686
        }

18687


18688
        (childS)->regDataType.arg1 = ((void *)(childS));

18689
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

18690
          FcnSetErrorStatus);

18691
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

18692
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

18693
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

18694
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

18695


18696
        /* registration */

18697
#if defined(MATLAB_MEX_FILE)

18698


18699
        {

18700
          int_T i;

18701
          mxArray *plhs[1];

18702
          mxArray *prhs[4];

18703
          double *pr;

18704
          volatile int_T *intS = (int_T *)&childS;

18705
          int_T addrlen = sizeof(SimStruct *);

18706
          int_T m = addrlen/sizeof(int_T) + 1;

18707
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

18708
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

18709
          pr = mxGetPr(prhs[1]);

18710
          for (i = 0; i < m - 1; i++) {

18711
            pr[i] = (double)intS[i];

18712
          }

18713


18714
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

18715
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

18716
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

18717


18718
          /* Reset port dimensions info functions because the S-function

18719
           * and accelerator mex-files explicitly set their dimensions,

18720
           * i.e., they are not dynamically sized. For this case, the

18721
           * mex-file is responsible for the dimensions info memory

18722
           * and Simulink should not free it. This is achieved by

18723
           * setting the following two methods to NULL.

18724
           */

18725
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

18726
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

18727


18728
          /*

18729
           * Setup function pointers and call mdlInitializeSizes via

18730
           * simulink.c

18731
           */

18732
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

18733
          mxDestroyArray(plhs[0]);

18734
          mxDestroyArray(prhs[0]);

18735
          mxDestroyArray(prhs[1]);

18736
          mxDestroyArray(prhs[2]);

18737
          mxDestroyArray(prhs[3]);

18738
        }

18739


18740
#else

18741


18742
        {

18743
          LeadLagFilter_sf(childS);

18744
          sfcnInitializeSizes(childS);

18745
        }

18746


18747
#endif

18748


18749
        sfcnInitializeSampleTimes(childS);

18750


18751
        /* adjust sample time */

18752
        ssSetSampleTime(childS, 0, 0.0);

18753
        ssSetOffsetTime(childS, 0, 0.0);

18754
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

18755


18756
        /* set compiled values of dynamic vector attributes */

18757
        ssSetNumNonsampledZCs(childS, 0);

18758


18759
        /* Update connectivity flags for each port */

18760
        _ssSetInputPortConnected(childS, 0, 1);

18761
        _ssSetInputPortConnected(childS, 1, 1);

18762
        _ssSetInputPortConnected(childS, 2, 1);

18763
        _ssSetInputPortConnected(childS, 3, 1);

18764
        _ssSetInputPortConnected(childS, 4, 1);

18765
        _ssSetInputPortConnected(childS, 5, 1);

18766
        _ssSetInputPortConnected(childS, 6, 1);

18767
        _ssSetOutputPortConnected(childS, 0, 1);

18768
        _ssSetOutputPortBeingMerged(childS, 0, 0);

18769


18770
        /* Update the BufferDstPort flags for each input port */

18771
        _ssSetInputPortBufferDstPort(childS, 0, -1);

18772
        _ssSetInputPortBufferDstPort(childS, 1, -1);

18773
        _ssSetInputPortBufferDstPort(childS, 2, -1);

18774
        _ssSetInputPortBufferDstPort(childS, 3, -1);

18775
        _ssSetInputPortBufferDstPort(childS, 4, -1);

18776
        _ssSetInputPortBufferDstPort(childS, 5, -1);

18777
        _ssSetInputPortBufferDstPort(childS, 6, -1);

18778
      }

18779


18780
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S149>/Generated S-Function4 (LagFilter_sf) */

18781
      {

18782
        SimStruct *childS = ssGetSFunction(rts, 70);

18783


18784
        /* timing info */

18785
        time_T *sfcnPeriod;

18786
        time_T *sfcnOffset;

18787
        int_T *sfcnTsMap;

18788
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

18789
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

18790
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

18791
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

18792
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

18793
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

18794
        (void) memset((void*)sfcnPeriod, 0,

18795
                      sizeof(time_T)*1);

18796
        (void) memset((void*)sfcnOffset, 0,

18797
                      sizeof(time_T)*1);

18798
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

18799
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

18800
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

18801


18802
        /* Set up the mdlInfo pointer */

18803
# ifdef USE_RTMODEL

18804


18805
        {

18806
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

18807
              struct _ssBlkInfo2));

18808
          ss_VALIDATE_MEMORY(rts,blkInfo2);

18809
          ssSetBlkInfo2Ptr(childS, blkInfo2);

18810
        }

18811


18812
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

18813


18814
# else

18815


18816
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

18817


18818
# endif                                /* USE_RTMODEL */

18819


18820
        /* Allocate memory of model methods 2 */

18821
        {

18822
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

18823
            malloc(sizeof(struct _ssSFcnModelMethods2));

18824
          ss_VALIDATE_MEMORY(rts,methods2);

18825
          ssSetModelMethods2(childS, methods2);

18826
        }

18827


18828
        /* Allocate memory of model methods 3 */

18829
        {

18830
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

18831
            malloc(sizeof(struct _ssSFcnModelMethods3));

18832
          ss_VALIDATE_MEMORY(rts,methods3);

18833
          ssSetModelMethods3(childS, methods3);

18834
        }

18835


18836
        /* Allocate memory for states auxilliary information */

18837
        {

18838
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

18839
            (sizeof(struct _ssStatesInfo2));

18840
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

18841
            malloc(sizeof(ssPeriodicStatesInfo));

18842
          ss_VALIDATE_MEMORY(rts,statesInfo2);

18843
          ssSetStatesInfo2(childS, statesInfo2);

18844
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

18845
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

18846
        }

18847


18848
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

18849
          RegNumInputPorts);

18850
        ssSetRegNumInputPortsFcnArg(childS,childS);

18851


18852
        /* inputs */

18853
        {

18854
          struct _ssPortInputs *inputPortInfo =

18855
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

18856
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

18857
          _ssSetNumInputPorts(childS, 6);

18858
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

18859


18860
          /* port 0 */

18861
          {

18862
            real32_T const **sfcnUPtrs = (real32_T const **)

18863
              malloc(1 * sizeof(real32_T *));

18864
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18865
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18866
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

18867
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

18868
            _ssSetInputPortNumDimensions(childS, 0, 1);

18869
            ssSetInputPortWidth(childS, 0, 1);

18870
          }

18871


18872
          /* port 1 */

18873
          {

18874
            int8_T const **sfcnUPtrs = (int8_T const **)

18875
              malloc(1 * sizeof(int8_T *));

18876
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18877
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

18878
              ssGetLocalBlockIO(rts))->DataTypeConversion1_h;

18879
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

18880
            _ssSetInputPortNumDimensions(childS, 1, 1);

18881
            ssSetInputPortWidth(childS, 1, 1);

18882
          }

18883


18884
          /* port 2 */

18885
          {

18886
            real32_T const **sfcnUPtrs = (real32_T const **)

18887
              malloc(1 * sizeof(real32_T *));

18888
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18889
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

18890
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

18891
            _ssSetInputPortNumDimensions(childS, 2, 1);

18892
            ssSetInputPortWidth(childS, 2, 1);

18893
          }

18894


18895
          /* port 3 */

18896
          {

18897
            real32_T const **sfcnUPtrs = (real32_T const **)

18898
              malloc(1 * sizeof(real32_T *));

18899
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18900
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18901
              ssGetLocalBlockIO(rts))->Switch_bg;

18902
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

18903
            _ssSetInputPortNumDimensions(childS, 3, 1);

18904
            ssSetInputPortWidth(childS, 3, 1);

18905
          }

18906


18907
          /* port 4 */

18908
          {

18909
            real32_T const **sfcnUPtrs = (real32_T const **)

18910
              malloc(1 * sizeof(real32_T *));

18911
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18912
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18913
              ssGetLocalBlockIO(rts))->Switch_bg;

18914
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

18915
            _ssSetInputPortNumDimensions(childS, 4, 1);

18916
            ssSetInputPortWidth(childS, 4, 1);

18917
          }

18918


18919
          /* port 5 */

18920
          {

18921
            real32_T const **sfcnUPtrs = (real32_T const **)

18922
              malloc(1 * sizeof(real32_T *));

18923
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

18924
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

18925
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_i;

18926
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

18927
            _ssSetInputPortNumDimensions(childS, 5, 1);

18928
            ssSetInputPortWidth(childS, 5, 1);

18929
          }

18930
        }

18931


18932
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

18933
          RegNumOutputPorts);

18934
        ssSetRegNumOutputPortsFcnArg(childS,childS);

18935


18936
        /* outputs */

18937
        {

18938
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

18939
            calloc(1, sizeof(struct _ssPortOutputs));

18940
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

18941
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

18942
          _ssSetNumOutputPorts(childS, 1);

18943


18944
          /* port 0 */

18945
          {

18946
            _ssSetOutputPortNumDimensions(childS, 0, 1);

18947
            ssSetOutputPortWidth(childS, 0, 1);

18948
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

18949
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_dc));

18950
          }

18951
        }

18952


18953
        /* path info */

18954
        _ssSetModelName(childS, "LagFilter_sf");

18955
        _ssSetPath(childS,

18956
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/ lag filter/Generated S-Function4");

18957
        if (ssGetRTModel(rts) == (NULL)) {

18958
          _ssSetParentSS(childS, rts);

18959
          _ssSetRootSS(childS, ssGetRootSS(rts));

18960
        } else {

18961
          ssSetRTModel(childS,ssGetRTModel(rts));

18962
          _ssSetParentSS(childS, (NULL));

18963
          _ssSetRootSS(childS, childS);

18964
        }

18965


18966
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

18967


18968
        /* work vectors */

18969
        {

18970
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

18971
            (4 * sizeof(struct _ssDWorkRecord));

18972
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

18973
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

18974
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

18975
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

18976
          ssSetSFcnDWork(childS, dWorkRecord);

18977
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

18978
          _ssSetNumDWork(childS, 4);

18979


18980
          /* DWORK0 */

18981
          ssSetDWorkWidth(childS, 0, 1);

18982
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

18983
          ssSetDWorkComplexSignal(childS, 0, 0);

18984
          ssSetDWorkUsedAsDState(childS, 0, 1);

18985
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 204))[0]);

18986


18987
          /* DWORK1 */

18988
          ssSetDWorkWidth(childS, 1, 1);

18989
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

18990
          ssSetDWorkComplexSignal(childS, 1, 0);

18991
          ssSetDWorkUsedAsDState(childS, 1, 1);

18992
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 205))[0]);

18993


18994
          /* DWORK2 */

18995
          ssSetDWorkWidth(childS, 2, 1);

18996
          ssSetDWorkDataType(childS, 2,SS_INT8);

18997
          ssSetDWorkComplexSignal(childS, 2, 0);

18998
          ssSetDWorkUsedAsDState(childS, 2, 1);

18999
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 431))[0]);

19000


19001
          /* DWORK3 */

19002
          ssSetDWorkWidth(childS, 3, 1);

19003
          ssSetDWorkDataType(childS, 3,SS_INT8);

19004
          ssSetDWorkComplexSignal(childS, 3, 0);

19005
          ssSetDWorkUsedAsDState(childS, 3, 1);

19006
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 432))[0]);

19007
        }

19008


19009
        (childS)->regDataType.arg1 = ((void *)(childS));

19010
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

19011
          FcnSetErrorStatus);

19012
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

19013
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

19014
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

19015
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

19016


19017
        /* registration */

19018
#if defined(MATLAB_MEX_FILE)

19019


19020
        {

19021
          int_T i;

19022
          mxArray *plhs[1];

19023
          mxArray *prhs[4];

19024
          double *pr;

19025
          volatile int_T *intS = (int_T *)&childS;

19026
          int_T addrlen = sizeof(SimStruct *);

19027
          int_T m = addrlen/sizeof(int_T) + 1;

19028
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

19029
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

19030
          pr = mxGetPr(prhs[1]);

19031
          for (i = 0; i < m - 1; i++) {

19032
            pr[i] = (double)intS[i];

19033
          }

19034


19035
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

19036
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

19037
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

19038


19039
          /* Reset port dimensions info functions because the S-function

19040
           * and accelerator mex-files explicitly set their dimensions,

19041
           * i.e., they are not dynamically sized. For this case, the

19042
           * mex-file is responsible for the dimensions info memory

19043
           * and Simulink should not free it. This is achieved by

19044
           * setting the following two methods to NULL.

19045
           */

19046
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

19047
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

19048


19049
          /*

19050
           * Setup function pointers and call mdlInitializeSizes via

19051
           * simulink.c

19052
           */

19053
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

19054
          mxDestroyArray(plhs[0]);

19055
          mxDestroyArray(prhs[0]);

19056
          mxDestroyArray(prhs[1]);

19057
          mxDestroyArray(prhs[2]);

19058
          mxDestroyArray(prhs[3]);

19059
        }

19060


19061
#else

19062


19063
        {

19064
          LagFilter_sf(childS);

19065
          sfcnInitializeSizes(childS);

19066
        }

19067


19068
#endif

19069


19070
        sfcnInitializeSampleTimes(childS);

19071


19072
        /* adjust sample time */

19073
        ssSetSampleTime(childS, 0, 0.0);

19074
        ssSetOffsetTime(childS, 0, 0.0);

19075
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

19076


19077
        /* set compiled values of dynamic vector attributes */

19078
        ssSetNumNonsampledZCs(childS, 0);

19079


19080
        /* Update connectivity flags for each port */

19081
        _ssSetInputPortConnected(childS, 0, 1);

19082
        _ssSetInputPortConnected(childS, 1, 1);

19083
        _ssSetInputPortConnected(childS, 2, 1);

19084
        _ssSetInputPortConnected(childS, 3, 1);

19085
        _ssSetInputPortConnected(childS, 4, 1);

19086
        _ssSetInputPortConnected(childS, 5, 1);

19087
        _ssSetOutputPortConnected(childS, 0, 1);

19088
        _ssSetOutputPortBeingMerged(childS, 0, 0);

19089


19090
        /* Update the BufferDstPort flags for each input port */

19091
        _ssSetInputPortBufferDstPort(childS, 0, -1);

19092
        _ssSetInputPortBufferDstPort(childS, 1, -1);

19093
        _ssSetInputPortBufferDstPort(childS, 2, -1);

19094
        _ssSetInputPortBufferDstPort(childS, 3, -1);

19095
        _ssSetInputPortBufferDstPort(childS, 4, -1);

19096
        _ssSetInputPortBufferDstPort(childS, 5, -1);

19097
      }

19098


19099
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S145>/Generated S-Function1 (SaturationLimiter_sf) */

19100
      {

19101
        SimStruct *childS = ssGetSFunction(rts, 71);

19102


19103
        /* timing info */

19104
        time_T *sfcnPeriod;

19105
        time_T *sfcnOffset;

19106
        int_T *sfcnTsMap;

19107
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

19108
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

19109
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

19110
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

19111
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

19112
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

19113
        (void) memset((void*)sfcnPeriod, 0,

19114
                      sizeof(time_T)*1);

19115
        (void) memset((void*)sfcnOffset, 0,

19116
                      sizeof(time_T)*1);

19117
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

19118
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

19119
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

19120


19121
        /* Set up the mdlInfo pointer */

19122
# ifdef USE_RTMODEL

19123


19124
        {

19125
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

19126
              struct _ssBlkInfo2));

19127
          ss_VALIDATE_MEMORY(rts,blkInfo2);

19128
          ssSetBlkInfo2Ptr(childS, blkInfo2);

19129
        }

19130


19131
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

19132


19133
# else

19134


19135
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

19136


19137
# endif                                /* USE_RTMODEL */

19138


19139
        /* Allocate memory of model methods 2 */

19140
        {

19141
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

19142
            malloc(sizeof(struct _ssSFcnModelMethods2));

19143
          ss_VALIDATE_MEMORY(rts,methods2);

19144
          ssSetModelMethods2(childS, methods2);

19145
        }

19146


19147
        /* Allocate memory of model methods 3 */

19148
        {

19149
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

19150
            malloc(sizeof(struct _ssSFcnModelMethods3));

19151
          ss_VALIDATE_MEMORY(rts,methods3);

19152
          ssSetModelMethods3(childS, methods3);

19153
        }

19154


19155
        /* Allocate memory for states auxilliary information */

19156
        {

19157
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

19158
            (sizeof(struct _ssStatesInfo2));

19159
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

19160
            malloc(sizeof(ssPeriodicStatesInfo));

19161
          ss_VALIDATE_MEMORY(rts,statesInfo2);

19162
          ssSetStatesInfo2(childS, statesInfo2);

19163
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

19164
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

19165
        }

19166


19167
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

19168
          RegNumInputPorts);

19169
        ssSetRegNumInputPortsFcnArg(childS,childS);

19170


19171
        /* inputs */

19172
        {

19173
          struct _ssPortInputs *inputPortInfo =

19174
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

19175
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

19176
          _ssSetNumInputPorts(childS, 3);

19177
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

19178


19179
          /* port 0 */

19180
          {

19181
            real32_T const **sfcnUPtrs = (real32_T const **)

19182
              malloc(1 * sizeof(real32_T *));

19183
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19184
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

19185
              ssGetLocalBlockIO(rts))->Divide_l;

19186
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

19187
            _ssSetInputPortNumDimensions(childS, 0, 1);

19188
            ssSetInputPortWidth(childS, 0, 1);

19189
          }

19190


19191
          /* port 1 */

19192
          {

19193
            real32_T const **sfcnUPtrs = (real32_T const **)

19194
              malloc(1 * sizeof(real32_T *));

19195
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19196
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

19197
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

19198
            _ssSetInputPortNumDimensions(childS, 1, 1);

19199
            ssSetInputPortWidth(childS, 1, 1);

19200
          }

19201


19202
          /* port 2 */

19203
          {

19204
            real32_T const **sfcnUPtrs = (real32_T const **)

19205
              malloc(1 * sizeof(real32_T *));

19206
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19207
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

19208
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

19209
            _ssSetInputPortNumDimensions(childS, 2, 1);

19210
            ssSetInputPortWidth(childS, 2, 1);

19211
          }

19212
        }

19213


19214
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

19215
          RegNumOutputPorts);

19216
        ssSetRegNumOutputPortsFcnArg(childS,childS);

19217


19218
        /* outputs */

19219
        {

19220
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

19221
            calloc(1, sizeof(struct _ssPortOutputs));

19222
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

19223
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

19224
          _ssSetNumOutputPorts(childS, 1);

19225


19226
          /* port 0 */

19227
          {

19228
            _ssSetOutputPortNumDimensions(childS, 0, 1);

19229
            ssSetOutputPortWidth(childS, 0, 1);

19230
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

19231
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_p));

19232
          }

19233
        }

19234


19235
        /* path info */

19236
        _ssSetModelName(childS, "SaturationLimiter_sf");

19237
        _ssSetPath(childS,

19238
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Saturation Limiter2/Generated S-Function1");

19239
        if (ssGetRTModel(rts) == (NULL)) {

19240
          _ssSetParentSS(childS, rts);

19241
          _ssSetRootSS(childS, ssGetRootSS(rts));

19242
        } else {

19243
          ssSetRTModel(childS,ssGetRTModel(rts));

19244
          _ssSetParentSS(childS, (NULL));

19245
          _ssSetRootSS(childS, childS);

19246
        }

19247


19248
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

19249
        (childS)->regDataType.arg1 = ((void *)(childS));

19250
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

19251
          FcnSetErrorStatus);

19252
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

19253
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

19254
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

19255
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

19256


19257
        /* registration */

19258
#if defined(MATLAB_MEX_FILE)

19259


19260
        {

19261
          int_T i;

19262
          mxArray *plhs[1];

19263
          mxArray *prhs[4];

19264
          double *pr;

19265
          volatile int_T *intS = (int_T *)&childS;

19266
          int_T addrlen = sizeof(SimStruct *);

19267
          int_T m = addrlen/sizeof(int_T) + 1;

19268
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

19269
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

19270
          pr = mxGetPr(prhs[1]);

19271
          for (i = 0; i < m - 1; i++) {

19272
            pr[i] = (double)intS[i];

19273
          }

19274


19275
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

19276
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

19277
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

19278


19279
          /* Reset port dimensions info functions because the S-function

19280
           * and accelerator mex-files explicitly set their dimensions,

19281
           * i.e., they are not dynamically sized. For this case, the

19282
           * mex-file is responsible for the dimensions info memory

19283
           * and Simulink should not free it. This is achieved by

19284
           * setting the following two methods to NULL.

19285
           */

19286
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

19287
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

19288


19289
          /*

19290
           * Setup function pointers and call mdlInitializeSizes via

19291
           * simulink.c

19292
           */

19293
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

19294
          mxDestroyArray(plhs[0]);

19295
          mxDestroyArray(prhs[0]);

19296
          mxDestroyArray(prhs[1]);

19297
          mxDestroyArray(prhs[2]);

19298
          mxDestroyArray(prhs[3]);

19299
        }

19300


19301
#else

19302


19303
        {

19304
          SaturationLimiter_sf(childS);

19305
          sfcnInitializeSizes(childS);

19306
        }

19307


19308
#endif

19309


19310
        sfcnInitializeSampleTimes(childS);

19311


19312
        /* adjust sample time */

19313
        ssSetSampleTime(childS, 0, 0.005);

19314
        ssSetOffsetTime(childS, 0, 0.0);

19315
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];

19316


19317
        /* set compiled values of dynamic vector attributes */

19318
        ssSetNumNonsampledZCs(childS, 0);

19319


19320
        /* Update connectivity flags for each port */

19321
        _ssSetInputPortConnected(childS, 0, 1);

19322
        _ssSetInputPortConnected(childS, 1, 1);

19323
        _ssSetInputPortConnected(childS, 2, 1);

19324
        _ssSetOutputPortConnected(childS, 0, 1);

19325
        _ssSetOutputPortBeingMerged(childS, 0, 0);

19326


19327
        /* Update the BufferDstPort flags for each input port */

19328
        _ssSetInputPortBufferDstPort(childS, 0, -1);

19329
        _ssSetInputPortBufferDstPort(childS, 1, -1);

19330
        _ssSetInputPortBufferDstPort(childS, 2, -1);

19331
      }

19332


19333
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S127>/Generated S-Function6 (Res180_sf) */

19334
      {

19335
        SimStruct *childS = ssGetSFunction(rts, 72);

19336


19337
        /* timing info */

19338
        time_T *sfcnPeriod;

19339
        time_T *sfcnOffset;

19340
        int_T *sfcnTsMap;

19341
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

19342
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

19343
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

19344
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

19345
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

19346
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

19347
        (void) memset((void*)sfcnPeriod, 0,

19348
                      sizeof(time_T)*1);

19349
        (void) memset((void*)sfcnOffset, 0,

19350
                      sizeof(time_T)*1);

19351
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

19352
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

19353
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

19354


19355
        /* Set up the mdlInfo pointer */

19356
# ifdef USE_RTMODEL

19357


19358
        {

19359
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

19360
              struct _ssBlkInfo2));

19361
          ss_VALIDATE_MEMORY(rts,blkInfo2);

19362
          ssSetBlkInfo2Ptr(childS, blkInfo2);

19363
        }

19364


19365
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

19366


19367
# else

19368


19369
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

19370


19371
# endif                                /* USE_RTMODEL */

19372


19373
        /* Allocate memory of model methods 2 */

19374
        {

19375
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

19376
            malloc(sizeof(struct _ssSFcnModelMethods2));

19377
          ss_VALIDATE_MEMORY(rts,methods2);

19378
          ssSetModelMethods2(childS, methods2);

19379
        }

19380


19381
        /* Allocate memory of model methods 3 */

19382
        {

19383
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

19384
            malloc(sizeof(struct _ssSFcnModelMethods3));

19385
          ss_VALIDATE_MEMORY(rts,methods3);

19386
          ssSetModelMethods3(childS, methods3);

19387
        }

19388


19389
        /* Allocate memory for states auxilliary information */

19390
        {

19391
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

19392
            (sizeof(struct _ssStatesInfo2));

19393
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

19394
            malloc(sizeof(ssPeriodicStatesInfo));

19395
          ss_VALIDATE_MEMORY(rts,statesInfo2);

19396
          ssSetStatesInfo2(childS, statesInfo2);

19397
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

19398
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

19399
        }

19400


19401
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

19402
          RegNumInputPorts);

19403
        ssSetRegNumInputPortsFcnArg(childS,childS);

19404


19405
        /* inputs */

19406
        {

19407
          struct _ssPortInputs *inputPortInfo =

19408
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

19409
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

19410
          _ssSetNumInputPorts(childS, 1);

19411
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

19412


19413
          /* port 0 */

19414
          {

19415
            real32_T const **sfcnUPtrs = (real32_T const **)

19416
              malloc(1 * sizeof(real32_T *));

19417
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19418
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

19419
              ssGetLocalBlockIO(rts))->Sum3_c;

19420
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

19421
            _ssSetInputPortNumDimensions(childS, 0, 1);

19422
            ssSetInputPortWidth(childS, 0, 1);

19423
          }

19424
        }

19425


19426
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

19427
          RegNumOutputPorts);

19428
        ssSetRegNumOutputPortsFcnArg(childS,childS);

19429


19430
        /* outputs */

19431
        {

19432
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

19433
            calloc(1, sizeof(struct _ssPortOutputs));

19434
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

19435
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

19436
          _ssSetNumOutputPorts(childS, 1);

19437


19438
          /* port 0 */

19439
          {

19440
            _ssSetOutputPortNumDimensions(childS, 0, 1);

19441
            ssSetOutputPortWidth(childS, 0, 1);

19442
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

19443
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_a));

19444
          }

19445
        }

19446


19447
        /* path info */

19448
        _ssSetModelName(childS, "Res180_sf");

19449
        _ssSetPath(childS,

19450
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Generated S-Function6");

19451
        if (ssGetRTModel(rts) == (NULL)) {

19452
          _ssSetParentSS(childS, rts);

19453
          _ssSetRootSS(childS, ssGetRootSS(rts));

19454
        } else {

19455
          ssSetRTModel(childS,ssGetRTModel(rts));

19456
          _ssSetParentSS(childS, (NULL));

19457
          _ssSetRootSS(childS, childS);

19458
        }

19459


19460
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

19461
        (childS)->regDataType.arg1 = ((void *)(childS));

19462
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

19463
          FcnSetErrorStatus);

19464
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

19465
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

19466
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

19467
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

19468


19469
        /* registration */

19470
#if defined(MATLAB_MEX_FILE)

19471


19472
        {

19473
          int_T i;

19474
          mxArray *plhs[1];

19475
          mxArray *prhs[4];

19476
          double *pr;

19477
          volatile int_T *intS = (int_T *)&childS;

19478
          int_T addrlen = sizeof(SimStruct *);

19479
          int_T m = addrlen/sizeof(int_T) + 1;

19480
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

19481
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

19482
          pr = mxGetPr(prhs[1]);

19483
          for (i = 0; i < m - 1; i++) {

19484
            pr[i] = (double)intS[i];

19485
          }

19486


19487
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

19488
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

19489
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

19490


19491
          /* Reset port dimensions info functions because the S-function

19492
           * and accelerator mex-files explicitly set their dimensions,

19493
           * i.e., they are not dynamically sized. For this case, the

19494
           * mex-file is responsible for the dimensions info memory

19495
           * and Simulink should not free it. This is achieved by

19496
           * setting the following two methods to NULL.

19497
           */

19498
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

19499
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

19500


19501
          /*

19502
           * Setup function pointers and call mdlInitializeSizes via

19503
           * simulink.c

19504
           */

19505
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

19506
          mxDestroyArray(plhs[0]);

19507
          mxDestroyArray(prhs[0]);

19508
          mxDestroyArray(prhs[1]);

19509
          mxDestroyArray(prhs[2]);

19510
          mxDestroyArray(prhs[3]);

19511
        }

19512


19513
#else

19514


19515
        {

19516
          Res180_sf(childS);

19517
          sfcnInitializeSizes(childS);

19518
        }

19519


19520
#endif

19521


19522
        sfcnInitializeSampleTimes(childS);

19523


19524
        /* adjust sample time */

19525
        ssSetSampleTime(childS, 0, 0.0);

19526
        ssSetOffsetTime(childS, 0, 0.0);

19527
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

19528


19529
        /* set compiled values of dynamic vector attributes */

19530
        ssSetNumNonsampledZCs(childS, 0);

19531


19532
        /* Update connectivity flags for each port */

19533
        _ssSetInputPortConnected(childS, 0, 1);

19534
        _ssSetOutputPortConnected(childS, 0, 1);

19535
        _ssSetOutputPortBeingMerged(childS, 0, 0);

19536


19537
        /* Update the BufferDstPort flags for each input port */

19538
        _ssSetInputPortBufferDstPort(childS, 0, -1);

19539
      }

19540


19541
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S144>/Generated S-Function1 (SaturationLimiter_sf) */

19542
      {

19543
        SimStruct *childS = ssGetSFunction(rts, 73);

19544


19545
        /* timing info */

19546
        time_T *sfcnPeriod;

19547
        time_T *sfcnOffset;

19548
        int_T *sfcnTsMap;

19549
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

19550
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

19551
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

19552
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

19553
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

19554
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

19555
        (void) memset((void*)sfcnPeriod, 0,

19556
                      sizeof(time_T)*1);

19557
        (void) memset((void*)sfcnOffset, 0,

19558
                      sizeof(time_T)*1);

19559
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

19560
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

19561
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

19562


19563
        /* Set up the mdlInfo pointer */

19564
# ifdef USE_RTMODEL

19565


19566
        {

19567
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

19568
              struct _ssBlkInfo2));

19569
          ss_VALIDATE_MEMORY(rts,blkInfo2);

19570
          ssSetBlkInfo2Ptr(childS, blkInfo2);

19571
        }

19572


19573
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

19574


19575
# else

19576


19577
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

19578


19579
# endif                                /* USE_RTMODEL */

19580


19581
        /* Allocate memory of model methods 2 */

19582
        {

19583
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

19584
            malloc(sizeof(struct _ssSFcnModelMethods2));

19585
          ss_VALIDATE_MEMORY(rts,methods2);

19586
          ssSetModelMethods2(childS, methods2);

19587
        }

19588


19589
        /* Allocate memory of model methods 3 */

19590
        {

19591
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

19592
            malloc(sizeof(struct _ssSFcnModelMethods3));

19593
          ss_VALIDATE_MEMORY(rts,methods3);

19594
          ssSetModelMethods3(childS, methods3);

19595
        }

19596


19597
        /* Allocate memory for states auxilliary information */

19598
        {

19599
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

19600
            (sizeof(struct _ssStatesInfo2));

19601
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

19602
            malloc(sizeof(ssPeriodicStatesInfo));

19603
          ss_VALIDATE_MEMORY(rts,statesInfo2);

19604
          ssSetStatesInfo2(childS, statesInfo2);

19605
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

19606
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

19607
        }

19608


19609
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

19610
          RegNumInputPorts);

19611
        ssSetRegNumInputPortsFcnArg(childS,childS);

19612


19613
        /* inputs */

19614
        {

19615
          struct _ssPortInputs *inputPortInfo =

19616
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

19617
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

19618
          _ssSetNumInputPorts(childS, 3);

19619
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

19620


19621
          /* port 0 */

19622
          {

19623
            real32_T const **sfcnUPtrs = (real32_T const **)

19624
              malloc(1 * sizeof(real32_T *));

19625
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19626
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

19627
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_a;

19628
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

19629
            _ssSetInputPortNumDimensions(childS, 0, 1);

19630
            ssSetInputPortWidth(childS, 0, 1);

19631
          }

19632


19633
          /* port 1 */

19634
          {

19635
            real32_T const **sfcnUPtrs = (real32_T const **)

19636
              malloc(1 * sizeof(real32_T *));

19637
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19638
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

19639
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

19640
            _ssSetInputPortNumDimensions(childS, 1, 1);

19641
            ssSetInputPortWidth(childS, 1, 1);

19642
          }

19643


19644
          /* port 2 */

19645
          {

19646
            real32_T const **sfcnUPtrs = (real32_T const **)

19647
              malloc(1 * sizeof(real32_T *));

19648
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19649
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;

19650
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

19651
            _ssSetInputPortNumDimensions(childS, 2, 1);

19652
            ssSetInputPortWidth(childS, 2, 1);

19653
          }

19654
        }

19655


19656
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

19657
          RegNumOutputPorts);

19658
        ssSetRegNumOutputPortsFcnArg(childS,childS);

19659


19660
        /* outputs */

19661
        {

19662
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

19663
            calloc(1, sizeof(struct _ssPortOutputs));

19664
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

19665
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

19666
          _ssSetNumOutputPorts(childS, 1);

19667


19668
          /* port 0 */

19669
          {

19670
            _ssSetOutputPortNumDimensions(childS, 0, 1);

19671
            ssSetOutputPortWidth(childS, 0, 1);

19672
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

19673
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_l1));

19674
          }

19675
        }

19676


19677
        /* path info */

19678
        _ssSetModelName(childS, "SaturationLimiter_sf");

19679
        _ssSetPath(childS,

19680
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Saturation Limiter1/Generated S-Function1");

19681
        if (ssGetRTModel(rts) == (NULL)) {

19682
          _ssSetParentSS(childS, rts);

19683
          _ssSetRootSS(childS, ssGetRootSS(rts));

19684
        } else {

19685
          ssSetRTModel(childS,ssGetRTModel(rts));

19686
          _ssSetParentSS(childS, (NULL));

19687
          _ssSetRootSS(childS, childS);

19688
        }

19689


19690
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

19691
        (childS)->regDataType.arg1 = ((void *)(childS));

19692
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

19693
          FcnSetErrorStatus);

19694
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

19695
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

19696
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

19697
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

19698


19699
        /* registration */

19700
#if defined(MATLAB_MEX_FILE)

19701


19702
        {

19703
          int_T i;

19704
          mxArray *plhs[1];

19705
          mxArray *prhs[4];

19706
          double *pr;

19707
          volatile int_T *intS = (int_T *)&childS;

19708
          int_T addrlen = sizeof(SimStruct *);

19709
          int_T m = addrlen/sizeof(int_T) + 1;

19710
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

19711
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

19712
          pr = mxGetPr(prhs[1]);

19713
          for (i = 0; i < m - 1; i++) {

19714
            pr[i] = (double)intS[i];

19715
          }

19716


19717
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

19718
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

19719
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

19720


19721
          /* Reset port dimensions info functions because the S-function

19722
           * and accelerator mex-files explicitly set their dimensions,

19723
           * i.e., they are not dynamically sized. For this case, the

19724
           * mex-file is responsible for the dimensions info memory

19725
           * and Simulink should not free it. This is achieved by

19726
           * setting the following two methods to NULL.

19727
           */

19728
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

19729
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

19730


19731
          /*

19732
           * Setup function pointers and call mdlInitializeSizes via

19733
           * simulink.c

19734
           */

19735
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

19736
          mxDestroyArray(plhs[0]);

19737
          mxDestroyArray(prhs[0]);

19738
          mxDestroyArray(prhs[1]);

19739
          mxDestroyArray(prhs[2]);

19740
          mxDestroyArray(prhs[3]);

19741
        }

19742


19743
#else

19744


19745
        {

19746
          SaturationLimiter_sf(childS);

19747
          sfcnInitializeSizes(childS);

19748
        }

19749


19750
#endif

19751


19752
        sfcnInitializeSampleTimes(childS);

19753


19754
        /* adjust sample time */

19755
        ssSetSampleTime(childS, 0, 0.0);

19756
        ssSetOffsetTime(childS, 0, 0.0);

19757
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

19758


19759
        /* set compiled values of dynamic vector attributes */

19760
        ssSetNumNonsampledZCs(childS, 0);

19761


19762
        /* Update connectivity flags for each port */

19763
        _ssSetInputPortConnected(childS, 0, 1);

19764
        _ssSetInputPortConnected(childS, 1, 1);

19765
        _ssSetInputPortConnected(childS, 2, 1);

19766
        _ssSetOutputPortConnected(childS, 0, 1);

19767
        _ssSetOutputPortBeingMerged(childS, 0, 0);

19768


19769
        /* Update the BufferDstPort flags for each input port */

19770
        _ssSetInputPortBufferDstPort(childS, 0, -1);

19771
        _ssSetInputPortBufferDstPort(childS, 1, -1);

19772
        _ssSetInputPortBufferDstPort(childS, 2, -1);

19773
      }

19774


19775
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S148>/Generated S-Function (Gain_sf) */

19776
      {

19777
        SimStruct *childS = ssGetSFunction(rts, 74);

19778


19779
        /* timing info */

19780
        time_T *sfcnPeriod;

19781
        time_T *sfcnOffset;

19782
        int_T *sfcnTsMap;

19783
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

19784
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

19785
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

19786
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

19787
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

19788
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

19789
        (void) memset((void*)sfcnPeriod, 0,

19790
                      sizeof(time_T)*1);

19791
        (void) memset((void*)sfcnOffset, 0,

19792
                      sizeof(time_T)*1);

19793
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

19794
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

19795
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

19796


19797
        /* Set up the mdlInfo pointer */

19798
# ifdef USE_RTMODEL

19799


19800
        {

19801
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

19802
              struct _ssBlkInfo2));

19803
          ss_VALIDATE_MEMORY(rts,blkInfo2);

19804
          ssSetBlkInfo2Ptr(childS, blkInfo2);

19805
        }

19806


19807
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

19808


19809
# else

19810


19811
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

19812


19813
# endif                                /* USE_RTMODEL */

19814


19815
        /* Allocate memory of model methods 2 */

19816
        {

19817
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

19818
            malloc(sizeof(struct _ssSFcnModelMethods2));

19819
          ss_VALIDATE_MEMORY(rts,methods2);

19820
          ssSetModelMethods2(childS, methods2);

19821
        }

19822


19823
        /* Allocate memory of model methods 3 */

19824
        {

19825
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

19826
            malloc(sizeof(struct _ssSFcnModelMethods3));

19827
          ss_VALIDATE_MEMORY(rts,methods3);

19828
          ssSetModelMethods3(childS, methods3);

19829
        }

19830


19831
        /* Allocate memory for states auxilliary information */

19832
        {

19833
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

19834
            (sizeof(struct _ssStatesInfo2));

19835
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

19836
            malloc(sizeof(ssPeriodicStatesInfo));

19837
          ss_VALIDATE_MEMORY(rts,statesInfo2);

19838
          ssSetStatesInfo2(childS, statesInfo2);

19839
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

19840
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

19841
        }

19842


19843
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

19844
          RegNumInputPorts);

19845
        ssSetRegNumInputPortsFcnArg(childS,childS);

19846


19847
        /* inputs */

19848
        {

19849
          struct _ssPortInputs *inputPortInfo =

19850
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

19851
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

19852
          _ssSetNumInputPorts(childS, 2);

19853
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

19854


19855
          /* port 0 */

19856
          {

19857
            real32_T const **sfcnUPtrs = (real32_T const **)

19858
              malloc(1 * sizeof(real32_T *));

19859
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19860
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

19861
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_l1;

19862
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

19863
            _ssSetInputPortNumDimensions(childS, 0, 1);

19864
            ssSetInputPortWidth(childS, 0, 1);

19865
          }

19866


19867
          /* port 1 */

19868
          {

19869
            real32_T const **sfcnUPtrs = (real32_T const **)

19870
              malloc(1 * sizeof(real32_T *));

19871
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

19872
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

19873
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

19874
            _ssSetInputPortNumDimensions(childS, 1, 1);

19875
            ssSetInputPortWidth(childS, 1, 1);

19876
          }

19877
        }

19878


19879
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

19880
          RegNumOutputPorts);

19881
        ssSetRegNumOutputPortsFcnArg(childS,childS);

19882


19883
        /* outputs */

19884
        {

19885
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

19886
            calloc(1, sizeof(struct _ssPortOutputs));

19887
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

19888
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

19889
          _ssSetNumOutputPorts(childS, 1);

19890


19891
          /* port 0 */

19892
          {

19893
            _ssSetOutputPortNumDimensions(childS, 0, 1);

19894
            ssSetOutputPortWidth(childS, 0, 1);

19895
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

19896
              ssGetLocalBlockIO(rts))->GeneratedSFunction_cv));

19897
          }

19898
        }

19899


19900
        /* path info */

19901
        _ssSetModelName(childS, "Gain_sf");

19902
        _ssSetPath(childS,

19903
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/gain2/Generated S-Function");

19904
        if (ssGetRTModel(rts) == (NULL)) {

19905
          _ssSetParentSS(childS, rts);

19906
          _ssSetRootSS(childS, ssGetRootSS(rts));

19907
        } else {

19908
          ssSetRTModel(childS,ssGetRTModel(rts));

19909
          _ssSetParentSS(childS, (NULL));

19910
          _ssSetRootSS(childS, childS);

19911
        }

19912


19913
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

19914
        (childS)->regDataType.arg1 = ((void *)(childS));

19915
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

19916
          FcnSetErrorStatus);

19917
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

19918
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

19919
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

19920
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

19921


19922
        /* registration */

19923
#if defined(MATLAB_MEX_FILE)

19924


19925
        {

19926
          int_T i;

19927
          mxArray *plhs[1];

19928
          mxArray *prhs[4];

19929
          double *pr;

19930
          volatile int_T *intS = (int_T *)&childS;

19931
          int_T addrlen = sizeof(SimStruct *);

19932
          int_T m = addrlen/sizeof(int_T) + 1;

19933
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

19934
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

19935
          pr = mxGetPr(prhs[1]);

19936
          for (i = 0; i < m - 1; i++) {

19937
            pr[i] = (double)intS[i];

19938
          }

19939


19940
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

19941
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

19942
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

19943


19944
          /* Reset port dimensions info functions because the S-function

19945
           * and accelerator mex-files explicitly set their dimensions,

19946
           * i.e., they are not dynamically sized. For this case, the

19947
           * mex-file is responsible for the dimensions info memory

19948
           * and Simulink should not free it. This is achieved by

19949
           * setting the following two methods to NULL.

19950
           */

19951
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

19952
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

19953


19954
          /*

19955
           * Setup function pointers and call mdlInitializeSizes via

19956
           * simulink.c

19957
           */

19958
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

19959
          mxDestroyArray(plhs[0]);

19960
          mxDestroyArray(prhs[0]);

19961
          mxDestroyArray(prhs[1]);

19962
          mxDestroyArray(prhs[2]);

19963
          mxDestroyArray(prhs[3]);

19964
        }

19965


19966
#else

19967


19968
        {

19969
          Gain_sf(childS);

19970
          sfcnInitializeSizes(childS);

19971
        }

19972


19973
#endif

19974


19975
        sfcnInitializeSampleTimes(childS);

19976


19977
        /* adjust sample time */

19978
        ssSetSampleTime(childS, 0, 0.0);

19979
        ssSetOffsetTime(childS, 0, 0.0);

19980
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

19981


19982
        /* set compiled values of dynamic vector attributes */

19983
        ssSetNumNonsampledZCs(childS, 0);

19984


19985
        /* Update connectivity flags for each port */

19986
        _ssSetInputPortConnected(childS, 0, 1);

19987
        _ssSetInputPortConnected(childS, 1, 1);

19988
        _ssSetOutputPortConnected(childS, 0, 1);

19989
        _ssSetOutputPortBeingMerged(childS, 0, 0);

19990


19991
        /* Update the BufferDstPort flags for each input port */

19992
        _ssSetInputPortBufferDstPort(childS, 0, -1);

19993
        _ssSetInputPortBufferDstPort(childS, 1, -1);

19994
      }

19995


19996
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S142>/Generated S-Function2 (LeadLagFilter_sf) */

19997
      {

19998
        SimStruct *childS = ssGetSFunction(rts, 75);

19999


20000
        /* timing info */

20001
        time_T *sfcnPeriod;

20002
        time_T *sfcnOffset;

20003
        int_T *sfcnTsMap;

20004
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

20005
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

20006
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

20007
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

20008
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

20009
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

20010
        (void) memset((void*)sfcnPeriod, 0,

20011
                      sizeof(time_T)*1);

20012
        (void) memset((void*)sfcnOffset, 0,

20013
                      sizeof(time_T)*1);

20014
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

20015
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

20016
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

20017


20018
        /* Set up the mdlInfo pointer */

20019
# ifdef USE_RTMODEL

20020


20021
        {

20022
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

20023
              struct _ssBlkInfo2));

20024
          ss_VALIDATE_MEMORY(rts,blkInfo2);

20025
          ssSetBlkInfo2Ptr(childS, blkInfo2);

20026
        }

20027


20028
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

20029


20030
# else

20031


20032
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

20033


20034
# endif                                /* USE_RTMODEL */

20035


20036
        /* Allocate memory of model methods 2 */

20037
        {

20038
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

20039
            malloc(sizeof(struct _ssSFcnModelMethods2));

20040
          ss_VALIDATE_MEMORY(rts,methods2);

20041
          ssSetModelMethods2(childS, methods2);

20042
        }

20043


20044
        /* Allocate memory of model methods 3 */

20045
        {

20046
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

20047
            malloc(sizeof(struct _ssSFcnModelMethods3));

20048
          ss_VALIDATE_MEMORY(rts,methods3);

20049
          ssSetModelMethods3(childS, methods3);

20050
        }

20051


20052
        /* Allocate memory for states auxilliary information */

20053
        {

20054
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

20055
            (sizeof(struct _ssStatesInfo2));

20056
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

20057
            malloc(sizeof(ssPeriodicStatesInfo));

20058
          ss_VALIDATE_MEMORY(rts,statesInfo2);

20059
          ssSetStatesInfo2(childS, statesInfo2);

20060
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

20061
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

20062
        }

20063


20064
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

20065
          RegNumInputPorts);

20066
        ssSetRegNumInputPortsFcnArg(childS,childS);

20067


20068
        /* inputs */

20069
        {

20070
          struct _ssPortInputs *inputPortInfo =

20071
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

20072
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

20073
          _ssSetNumInputPorts(childS, 7);

20074
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

20075


20076
          /* port 0 */

20077
          {

20078
            real32_T const **sfcnUPtrs = (real32_T const **)

20079
              malloc(1 * sizeof(real32_T *));

20080
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20081
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

20082
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

20083
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

20084
            _ssSetInputPortNumDimensions(childS, 0, 1);

20085
            ssSetInputPortWidth(childS, 0, 1);

20086
          }

20087


20088
          /* port 1 */

20089
          {

20090
            int8_T const **sfcnUPtrs = (int8_T const **)

20091
              malloc(1 * sizeof(int8_T *));

20092
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20093
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

20094
              ssGetLocalBlockIO(rts))->DataTypeConversion2_p;

20095
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

20096
            _ssSetInputPortNumDimensions(childS, 1, 1);

20097
            ssSetInputPortWidth(childS, 1, 1);

20098
          }

20099


20100
          /* port 2 */

20101
          {

20102
            real32_T const **sfcnUPtrs = (real32_T const **)

20103
              malloc(1 * sizeof(real32_T *));

20104
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20105
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

20106
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

20107
            _ssSetInputPortNumDimensions(childS, 2, 1);

20108
            ssSetInputPortWidth(childS, 2, 1);

20109
          }

20110


20111
          /* port 3 */

20112
          {

20113
            real32_T const **sfcnUPtrs = (real32_T const **)

20114
              malloc(1 * sizeof(real32_T *));

20115
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20116
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

20117
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

20118
            _ssSetInputPortNumDimensions(childS, 3, 1);

20119
            ssSetInputPortWidth(childS, 3, 1);

20120
          }

20121


20122
          /* port 4 */

20123
          {

20124
            real32_T const **sfcnUPtrs = (real32_T const **)

20125
              malloc(1 * sizeof(real32_T *));

20126
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20127
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

20128
              ssGetLocalBlockIO(rts))->Sum4_i;

20129
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

20130
            _ssSetInputPortNumDimensions(childS, 4, 1);

20131
            ssSetInputPortWidth(childS, 4, 1);

20132
          }

20133


20134
          /* port 5 */

20135
          {

20136
            real32_T const **sfcnUPtrs = (real32_T const **)

20137
              malloc(1 * sizeof(real32_T *));

20138
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20139
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

20140
              ssGetLocalBlockIO(rts))->Sum4_i;

20141
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

20142
            _ssSetInputPortNumDimensions(childS, 5, 1);

20143
            ssSetInputPortWidth(childS, 5, 1);

20144
          }

20145


20146
          /* port 6 */

20147
          {

20148
            real32_T const **sfcnUPtrs = (real32_T const **)

20149
              malloc(1 * sizeof(real32_T *));

20150
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20151
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

20152
              ssGetLocalBlockIO(rts))->GeneratedSFunction_cv;

20153
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

20154
            _ssSetInputPortNumDimensions(childS, 6, 1);

20155
            ssSetInputPortWidth(childS, 6, 1);

20156
          }

20157
        }

20158


20159
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

20160
          RegNumOutputPorts);

20161
        ssSetRegNumOutputPortsFcnArg(childS,childS);

20162


20163
        /* outputs */

20164
        {

20165
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

20166
            calloc(1, sizeof(struct _ssPortOutputs));

20167
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

20168
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

20169
          _ssSetNumOutputPorts(childS, 1);

20170


20171
          /* port 0 */

20172
          {

20173
            _ssSetOutputPortNumDimensions(childS, 0, 1);

20174
            ssSetOutputPortWidth(childS, 0, 1);

20175
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

20176
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_c));

20177
          }

20178
        }

20179


20180
        /* path info */

20181
        _ssSetModelName(childS, "LeadLagFilter_sf");

20182
        _ssSetPath(childS,

20183
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Lead lag1/Generated S-Function2");

20184
        if (ssGetRTModel(rts) == (NULL)) {

20185
          _ssSetParentSS(childS, rts);

20186
          _ssSetRootSS(childS, ssGetRootSS(rts));

20187
        } else {

20188
          ssSetRTModel(childS,ssGetRTModel(rts));

20189
          _ssSetParentSS(childS, (NULL));

20190
          _ssSetRootSS(childS, childS);

20191
        }

20192


20193
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

20194


20195
        /* work vectors */

20196
        {

20197
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

20198
            (4 * sizeof(struct _ssDWorkRecord));

20199
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

20200
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

20201
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

20202
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

20203
          ssSetSFcnDWork(childS, dWorkRecord);

20204
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

20205
          _ssSetNumDWork(childS, 4);

20206


20207
          /* DWORK0 */

20208
          ssSetDWorkWidth(childS, 0, 1);

20209
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

20210
          ssSetDWorkComplexSignal(childS, 0, 0);

20211
          ssSetDWorkUsedAsDState(childS, 0, 1);

20212
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 206))[0]);

20213


20214
          /* DWORK1 */

20215
          ssSetDWorkWidth(childS, 1, 1);

20216
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

20217
          ssSetDWorkComplexSignal(childS, 1, 0);

20218
          ssSetDWorkUsedAsDState(childS, 1, 1);

20219
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 207))[0]);

20220


20221
          /* DWORK2 */

20222
          ssSetDWorkWidth(childS, 2, 1);

20223
          ssSetDWorkDataType(childS, 2,SS_INT8);

20224
          ssSetDWorkComplexSignal(childS, 2, 0);

20225
          ssSetDWorkUsedAsDState(childS, 2, 1);

20226
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 433))[0]);

20227


20228
          /* DWORK3 */

20229
          ssSetDWorkWidth(childS, 3, 1);

20230
          ssSetDWorkDataType(childS, 3,SS_INT8);

20231
          ssSetDWorkComplexSignal(childS, 3, 0);

20232
          ssSetDWorkUsedAsDState(childS, 3, 1);

20233
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 434))[0]);

20234
        }

20235


20236
        (childS)->regDataType.arg1 = ((void *)(childS));

20237
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

20238
          FcnSetErrorStatus);

20239
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

20240
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

20241
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

20242
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

20243


20244
        /* registration */

20245
#if defined(MATLAB_MEX_FILE)

20246


20247
        {

20248
          int_T i;

20249
          mxArray *plhs[1];

20250
          mxArray *prhs[4];

20251
          double *pr;

20252
          volatile int_T *intS = (int_T *)&childS;

20253
          int_T addrlen = sizeof(SimStruct *);

20254
          int_T m = addrlen/sizeof(int_T) + 1;

20255
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

20256
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

20257
          pr = mxGetPr(prhs[1]);

20258
          for (i = 0; i < m - 1; i++) {

20259
            pr[i] = (double)intS[i];

20260
          }

20261


20262
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

20263
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

20264
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

20265


20266
          /* Reset port dimensions info functions because the S-function

20267
           * and accelerator mex-files explicitly set their dimensions,

20268
           * i.e., they are not dynamically sized. For this case, the

20269
           * mex-file is responsible for the dimensions info memory

20270
           * and Simulink should not free it. This is achieved by

20271
           * setting the following two methods to NULL.

20272
           */

20273
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

20274
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

20275


20276
          /*

20277
           * Setup function pointers and call mdlInitializeSizes via

20278
           * simulink.c

20279
           */

20280
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

20281
          mxDestroyArray(plhs[0]);

20282
          mxDestroyArray(prhs[0]);

20283
          mxDestroyArray(prhs[1]);

20284
          mxDestroyArray(prhs[2]);

20285
          mxDestroyArray(prhs[3]);

20286
        }

20287


20288
#else

20289


20290
        {

20291
          LeadLagFilter_sf(childS);

20292
          sfcnInitializeSizes(childS);

20293
        }

20294


20295
#endif

20296


20297
        sfcnInitializeSampleTimes(childS);

20298


20299
        /* adjust sample time */

20300
        ssSetSampleTime(childS, 0, 0.0);

20301
        ssSetOffsetTime(childS, 0, 0.0);

20302
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

20303


20304
        /* set compiled values of dynamic vector attributes */

20305
        ssSetNumNonsampledZCs(childS, 0);

20306


20307
        /* Update connectivity flags for each port */

20308
        _ssSetInputPortConnected(childS, 0, 1);

20309
        _ssSetInputPortConnected(childS, 1, 1);

20310
        _ssSetInputPortConnected(childS, 2, 1);

20311
        _ssSetInputPortConnected(childS, 3, 1);

20312
        _ssSetInputPortConnected(childS, 4, 1);

20313
        _ssSetInputPortConnected(childS, 5, 1);

20314
        _ssSetInputPortConnected(childS, 6, 1);

20315
        _ssSetOutputPortConnected(childS, 0, 1);

20316
        _ssSetOutputPortBeingMerged(childS, 0, 0);

20317


20318
        /* Update the BufferDstPort flags for each input port */

20319
        _ssSetInputPortBufferDstPort(childS, 0, -1);

20320
        _ssSetInputPortBufferDstPort(childS, 1, -1);

20321
        _ssSetInputPortBufferDstPort(childS, 2, -1);

20322
        _ssSetInputPortBufferDstPort(childS, 3, -1);

20323
        _ssSetInputPortBufferDstPort(childS, 4, -1);

20324
        _ssSetInputPortBufferDstPort(childS, 5, -1);

20325
        _ssSetInputPortBufferDstPort(childS, 6, -1);

20326
      }

20327


20328
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S143>/Generated S-Function1 (SaturationLimiter_sf) */

20329
      {

20330
        SimStruct *childS = ssGetSFunction(rts, 76);

20331


20332
        /* timing info */

20333
        time_T *sfcnPeriod;

20334
        time_T *sfcnOffset;

20335
        int_T *sfcnTsMap;

20336
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

20337
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

20338
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

20339
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

20340
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

20341
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

20342
        (void) memset((void*)sfcnPeriod, 0,

20343
                      sizeof(time_T)*1);

20344
        (void) memset((void*)sfcnOffset, 0,

20345
                      sizeof(time_T)*1);

20346
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

20347
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

20348
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

20349


20350
        /* Set up the mdlInfo pointer */

20351
# ifdef USE_RTMODEL

20352


20353
        {

20354
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

20355
              struct _ssBlkInfo2));

20356
          ss_VALIDATE_MEMORY(rts,blkInfo2);

20357
          ssSetBlkInfo2Ptr(childS, blkInfo2);

20358
        }

20359


20360
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

20361


20362
# else

20363


20364
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

20365


20366
# endif                                /* USE_RTMODEL */

20367


20368
        /* Allocate memory of model methods 2 */

20369
        {

20370
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

20371
            malloc(sizeof(struct _ssSFcnModelMethods2));

20372
          ss_VALIDATE_MEMORY(rts,methods2);

20373
          ssSetModelMethods2(childS, methods2);

20374
        }

20375


20376
        /* Allocate memory of model methods 3 */

20377
        {

20378
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

20379
            malloc(sizeof(struct _ssSFcnModelMethods3));

20380
          ss_VALIDATE_MEMORY(rts,methods3);

20381
          ssSetModelMethods3(childS, methods3);

20382
        }

20383


20384
        /* Allocate memory for states auxilliary information */

20385
        {

20386
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

20387
            (sizeof(struct _ssStatesInfo2));

20388
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

20389
            malloc(sizeof(ssPeriodicStatesInfo));

20390
          ss_VALIDATE_MEMORY(rts,statesInfo2);

20391
          ssSetStatesInfo2(childS, statesInfo2);

20392
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

20393
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

20394
        }

20395


20396
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

20397
          RegNumInputPorts);

20398
        ssSetRegNumInputPortsFcnArg(childS,childS);

20399


20400
        /* inputs */

20401
        {

20402
          struct _ssPortInputs *inputPortInfo =

20403
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

20404
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

20405
          _ssSetNumInputPorts(childS, 3);

20406
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

20407


20408
          /* port 0 */

20409
          {

20410
            real32_T const **sfcnUPtrs = (real32_T const **)

20411
              malloc(1 * sizeof(real32_T *));

20412
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20413
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

20414
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_c;

20415
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

20416
            _ssSetInputPortNumDimensions(childS, 0, 1);

20417
            ssSetInputPortWidth(childS, 0, 1);

20418
          }

20419


20420
          /* port 1 */

20421
          {

20422
            real32_T const **sfcnUPtrs = (real32_T const **)

20423
              malloc(1 * sizeof(real32_T *));

20424
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20425
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

20426
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

20427
            _ssSetInputPortNumDimensions(childS, 1, 1);

20428
            ssSetInputPortWidth(childS, 1, 1);

20429
          }

20430


20431
          /* port 2 */

20432
          {

20433
            real32_T const **sfcnUPtrs = (real32_T const **)

20434
              malloc(1 * sizeof(real32_T *));

20435
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20436
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

20437
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

20438
            _ssSetInputPortNumDimensions(childS, 2, 1);

20439
            ssSetInputPortWidth(childS, 2, 1);

20440
          }

20441
        }

20442


20443
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

20444
          RegNumOutputPorts);

20445
        ssSetRegNumOutputPortsFcnArg(childS,childS);

20446


20447
        /* outputs */

20448
        {

20449
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

20450
            calloc(1, sizeof(struct _ssPortOutputs));

20451
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

20452
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

20453
          _ssSetNumOutputPorts(childS, 1);

20454


20455
          /* port 0 */

20456
          {

20457
            _ssSetOutputPortNumDimensions(childS, 0, 1);

20458
            ssSetOutputPortWidth(childS, 0, 1);

20459
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

20460
              ssGetLocalBlockIO(rts))->Saturation2_p));

20461
          }

20462
        }

20463


20464
        /* path info */

20465
        _ssSetModelName(childS, "SaturationLimiter_sf");

20466
        _ssSetPath(childS,

20467
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Saturation Limiter/Generated S-Function1");

20468
        if (ssGetRTModel(rts) == (NULL)) {

20469
          _ssSetParentSS(childS, rts);

20470
          _ssSetRootSS(childS, ssGetRootSS(rts));

20471
        } else {

20472
          ssSetRTModel(childS,ssGetRTModel(rts));

20473
          _ssSetParentSS(childS, (NULL));

20474
          _ssSetRootSS(childS, childS);

20475
        }

20476


20477
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

20478
        (childS)->regDataType.arg1 = ((void *)(childS));

20479
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

20480
          FcnSetErrorStatus);

20481
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

20482
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

20483
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

20484
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

20485


20486
        /* registration */

20487
#if defined(MATLAB_MEX_FILE)

20488


20489
        {

20490
          int_T i;

20491
          mxArray *plhs[1];

20492
          mxArray *prhs[4];

20493
          double *pr;

20494
          volatile int_T *intS = (int_T *)&childS;

20495
          int_T addrlen = sizeof(SimStruct *);

20496
          int_T m = addrlen/sizeof(int_T) + 1;

20497
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

20498
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

20499
          pr = mxGetPr(prhs[1]);

20500
          for (i = 0; i < m - 1; i++) {

20501
            pr[i] = (double)intS[i];

20502
          }

20503


20504
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

20505
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

20506
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

20507


20508
          /* Reset port dimensions info functions because the S-function

20509
           * and accelerator mex-files explicitly set their dimensions,

20510
           * i.e., they are not dynamically sized. For this case, the

20511
           * mex-file is responsible for the dimensions info memory

20512
           * and Simulink should not free it. This is achieved by

20513
           * setting the following two methods to NULL.

20514
           */

20515
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

20516
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

20517


20518
          /*

20519
           * Setup function pointers and call mdlInitializeSizes via

20520
           * simulink.c

20521
           */

20522
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

20523
          mxDestroyArray(plhs[0]);

20524
          mxDestroyArray(prhs[0]);

20525
          mxDestroyArray(prhs[1]);

20526
          mxDestroyArray(prhs[2]);

20527
          mxDestroyArray(prhs[3]);

20528
        }

20529


20530
#else

20531


20532
        {

20533
          SaturationLimiter_sf(childS);

20534
          sfcnInitializeSizes(childS);

20535
        }

20536


20537
#endif

20538


20539
        sfcnInitializeSampleTimes(childS);

20540


20541
        /* adjust sample time */

20542
        ssSetSampleTime(childS, 0, 0.0);

20543
        ssSetOffsetTime(childS, 0, 0.0);

20544
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

20545


20546
        /* set compiled values of dynamic vector attributes */

20547
        ssSetNumNonsampledZCs(childS, 0);

20548


20549
        /* Update connectivity flags for each port */

20550
        _ssSetInputPortConnected(childS, 0, 1);

20551
        _ssSetInputPortConnected(childS, 1, 1);

20552
        _ssSetInputPortConnected(childS, 2, 1);

20553
        _ssSetOutputPortConnected(childS, 0, 1);

20554
        _ssSetOutputPortBeingMerged(childS, 0, 0);

20555


20556
        /* Update the BufferDstPort flags for each input port */

20557
        _ssSetInputPortBufferDstPort(childS, 0, -1);

20558
        _ssSetInputPortBufferDstPort(childS, 1, -1);

20559
        _ssSetInputPortBufferDstPort(childS, 2, -1);

20560
      }

20561


20562
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S127>/Generated S-Function1 (Res180_sf) */

20563
      {

20564
        SimStruct *childS = ssGetSFunction(rts, 77);

20565


20566
        /* timing info */

20567
        time_T *sfcnPeriod;

20568
        time_T *sfcnOffset;

20569
        int_T *sfcnTsMap;

20570
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

20571
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

20572
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

20573
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

20574
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

20575
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

20576
        (void) memset((void*)sfcnPeriod, 0,

20577
                      sizeof(time_T)*1);

20578
        (void) memset((void*)sfcnOffset, 0,

20579
                      sizeof(time_T)*1);

20580
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

20581
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

20582
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

20583


20584
        /* Set up the mdlInfo pointer */

20585
# ifdef USE_RTMODEL

20586


20587
        {

20588
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

20589
              struct _ssBlkInfo2));

20590
          ss_VALIDATE_MEMORY(rts,blkInfo2);

20591
          ssSetBlkInfo2Ptr(childS, blkInfo2);

20592
        }

20593


20594
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

20595


20596
# else

20597


20598
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

20599


20600
# endif                                /* USE_RTMODEL */

20601


20602
        /* Allocate memory of model methods 2 */

20603
        {

20604
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

20605
            malloc(sizeof(struct _ssSFcnModelMethods2));

20606
          ss_VALIDATE_MEMORY(rts,methods2);

20607
          ssSetModelMethods2(childS, methods2);

20608
        }

20609


20610
        /* Allocate memory of model methods 3 */

20611
        {

20612
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

20613
            malloc(sizeof(struct _ssSFcnModelMethods3));

20614
          ss_VALIDATE_MEMORY(rts,methods3);

20615
          ssSetModelMethods3(childS, methods3);

20616
        }

20617


20618
        /* Allocate memory for states auxilliary information */

20619
        {

20620
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

20621
            (sizeof(struct _ssStatesInfo2));

20622
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

20623
            malloc(sizeof(ssPeriodicStatesInfo));

20624
          ss_VALIDATE_MEMORY(rts,statesInfo2);

20625
          ssSetStatesInfo2(childS, statesInfo2);

20626
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

20627
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

20628
        }

20629


20630
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

20631
          RegNumInputPorts);

20632
        ssSetRegNumInputPortsFcnArg(childS,childS);

20633


20634
        /* inputs */

20635
        {

20636
          struct _ssPortInputs *inputPortInfo =

20637
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

20638
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

20639
          _ssSetNumInputPorts(childS, 1);

20640
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

20641


20642
          /* port 0 */

20643
          {

20644
            real32_T const **sfcnUPtrs = (real32_T const **)

20645
              malloc(1 * sizeof(real32_T *));

20646
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20647
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

20648
              ssGetLocalBlockIO(rts))->Sum1_ga;

20649
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

20650
            _ssSetInputPortNumDimensions(childS, 0, 1);

20651
            ssSetInputPortWidth(childS, 0, 1);

20652
          }

20653
        }

20654


20655
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

20656
          RegNumOutputPorts);

20657
        ssSetRegNumOutputPortsFcnArg(childS,childS);

20658


20659
        /* outputs */

20660
        {

20661
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

20662
            calloc(1, sizeof(struct _ssPortOutputs));

20663
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

20664
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

20665
          _ssSetNumOutputPorts(childS, 1);

20666


20667
          /* port 0 */

20668
          {

20669
            _ssSetOutputPortNumDimensions(childS, 0, 1);

20670
            ssSetOutputPortWidth(childS, 0, 1);

20671
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

20672
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_bh));

20673
          }

20674
        }

20675


20676
        /* path info */

20677
        _ssSetModelName(childS, "Res180_sf");

20678
        _ssSetPath(childS,

20679
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Generated S-Function1");

20680
        if (ssGetRTModel(rts) == (NULL)) {

20681
          _ssSetParentSS(childS, rts);

20682
          _ssSetRootSS(childS, ssGetRootSS(rts));

20683
        } else {

20684
          ssSetRTModel(childS,ssGetRTModel(rts));

20685
          _ssSetParentSS(childS, (NULL));

20686
          _ssSetRootSS(childS, childS);

20687
        }

20688


20689
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

20690
        (childS)->regDataType.arg1 = ((void *)(childS));

20691
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

20692
          FcnSetErrorStatus);

20693
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

20694
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

20695
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

20696
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

20697


20698
        /* registration */

20699
#if defined(MATLAB_MEX_FILE)

20700


20701
        {

20702
          int_T i;

20703
          mxArray *plhs[1];

20704
          mxArray *prhs[4];

20705
          double *pr;

20706
          volatile int_T *intS = (int_T *)&childS;

20707
          int_T addrlen = sizeof(SimStruct *);

20708
          int_T m = addrlen/sizeof(int_T) + 1;

20709
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

20710
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

20711
          pr = mxGetPr(prhs[1]);

20712
          for (i = 0; i < m - 1; i++) {

20713
            pr[i] = (double)intS[i];

20714
          }

20715


20716
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

20717
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

20718
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

20719


20720
          /* Reset port dimensions info functions because the S-function

20721
           * and accelerator mex-files explicitly set their dimensions,

20722
           * i.e., they are not dynamically sized. For this case, the

20723
           * mex-file is responsible for the dimensions info memory

20724
           * and Simulink should not free it. This is achieved by

20725
           * setting the following two methods to NULL.

20726
           */

20727
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

20728
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

20729


20730
          /*

20731
           * Setup function pointers and call mdlInitializeSizes via

20732
           * simulink.c

20733
           */

20734
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

20735
          mxDestroyArray(plhs[0]);

20736
          mxDestroyArray(prhs[0]);

20737
          mxDestroyArray(prhs[1]);

20738
          mxDestroyArray(prhs[2]);

20739
          mxDestroyArray(prhs[3]);

20740
        }

20741


20742
#else

20743


20744
        {

20745
          Res180_sf(childS);

20746
          sfcnInitializeSizes(childS);

20747
        }

20748


20749
#endif

20750


20751
        sfcnInitializeSampleTimes(childS);

20752


20753
        /* adjust sample time */

20754
        ssSetSampleTime(childS, 0, 0.0);

20755
        ssSetOffsetTime(childS, 0, 0.0);

20756
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

20757


20758
        /* set compiled values of dynamic vector attributes */

20759
        ssSetNumNonsampledZCs(childS, 0);

20760


20761
        /* Update connectivity flags for each port */

20762
        _ssSetInputPortConnected(childS, 0, 1);

20763
        _ssSetOutputPortConnected(childS, 0, 1);

20764
        _ssSetOutputPortBeingMerged(childS, 0, 0);

20765


20766
        /* Update the BufferDstPort flags for each input port */

20767
        _ssSetInputPortBufferDstPort(childS, 0, -1);

20768
      }

20769


20770
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S146>/Generated S-Function (Gain_sf) */

20771
      {

20772
        SimStruct *childS = ssGetSFunction(rts, 78);

20773


20774
        /* timing info */

20775
        time_T *sfcnPeriod;

20776
        time_T *sfcnOffset;

20777
        int_T *sfcnTsMap;

20778
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

20779
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

20780
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

20781
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

20782
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

20783
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

20784
        (void) memset((void*)sfcnPeriod, 0,

20785
                      sizeof(time_T)*1);

20786
        (void) memset((void*)sfcnOffset, 0,

20787
                      sizeof(time_T)*1);

20788
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

20789
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

20790
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

20791


20792
        /* Set up the mdlInfo pointer */

20793
# ifdef USE_RTMODEL

20794


20795
        {

20796
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

20797
              struct _ssBlkInfo2));

20798
          ss_VALIDATE_MEMORY(rts,blkInfo2);

20799
          ssSetBlkInfo2Ptr(childS, blkInfo2);

20800
        }

20801


20802
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

20803


20804
# else

20805


20806
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

20807


20808
# endif                                /* USE_RTMODEL */

20809


20810
        /* Allocate memory of model methods 2 */

20811
        {

20812
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

20813
            malloc(sizeof(struct _ssSFcnModelMethods2));

20814
          ss_VALIDATE_MEMORY(rts,methods2);

20815
          ssSetModelMethods2(childS, methods2);

20816
        }

20817


20818
        /* Allocate memory of model methods 3 */

20819
        {

20820
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

20821
            malloc(sizeof(struct _ssSFcnModelMethods3));

20822
          ss_VALIDATE_MEMORY(rts,methods3);

20823
          ssSetModelMethods3(childS, methods3);

20824
        }

20825


20826
        /* Allocate memory for states auxilliary information */

20827
        {

20828
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

20829
            (sizeof(struct _ssStatesInfo2));

20830
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

20831
            malloc(sizeof(ssPeriodicStatesInfo));

20832
          ss_VALIDATE_MEMORY(rts,statesInfo2);

20833
          ssSetStatesInfo2(childS, statesInfo2);

20834
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

20835
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

20836
        }

20837


20838
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

20839
          RegNumInputPorts);

20840
        ssSetRegNumInputPortsFcnArg(childS,childS);

20841


20842
        /* inputs */

20843
        {

20844
          struct _ssPortInputs *inputPortInfo =

20845
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

20846
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

20847
          _ssSetNumInputPorts(childS, 2);

20848
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

20849


20850
          /* port 0 */

20851
          {

20852
            real32_T const **sfcnUPtrs = (real32_T const **)

20853
              malloc(1 * sizeof(real32_T *));

20854
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20855
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

20856
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_bh;

20857
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

20858
            _ssSetInputPortNumDimensions(childS, 0, 1);

20859
            ssSetInputPortWidth(childS, 0, 1);

20860
          }

20861


20862
          /* port 1 */

20863
          {

20864
            real32_T const **sfcnUPtrs = (real32_T const **)

20865
              malloc(1 * sizeof(real32_T *));

20866
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

20867
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

20868
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

20869
            _ssSetInputPortNumDimensions(childS, 1, 1);

20870
            ssSetInputPortWidth(childS, 1, 1);

20871
          }

20872
        }

20873


20874
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

20875
          RegNumOutputPorts);

20876
        ssSetRegNumOutputPortsFcnArg(childS,childS);

20877


20878
        /* outputs */

20879
        {

20880
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

20881
            calloc(1, sizeof(struct _ssPortOutputs));

20882
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

20883
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

20884
          _ssSetNumOutputPorts(childS, 1);

20885


20886
          /* port 0 */

20887
          {

20888
            _ssSetOutputPortNumDimensions(childS, 0, 1);

20889
            ssSetOutputPortWidth(childS, 0, 1);

20890
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

20891
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ma));

20892
          }

20893
        }

20894


20895
        /* path info */

20896
        _ssSetModelName(childS, "Gain_sf");

20897
        _ssSetPath(childS,

20898
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/gain/Generated S-Function");

20899
        if (ssGetRTModel(rts) == (NULL)) {

20900
          _ssSetParentSS(childS, rts);

20901
          _ssSetRootSS(childS, ssGetRootSS(rts));

20902
        } else {

20903
          ssSetRTModel(childS,ssGetRTModel(rts));

20904
          _ssSetParentSS(childS, (NULL));

20905
          _ssSetRootSS(childS, childS);

20906
        }

20907


20908
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

20909
        (childS)->regDataType.arg1 = ((void *)(childS));

20910
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

20911
          FcnSetErrorStatus);

20912
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

20913
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

20914
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

20915
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

20916


20917
        /* registration */

20918
#if defined(MATLAB_MEX_FILE)

20919


20920
        {

20921
          int_T i;

20922
          mxArray *plhs[1];

20923
          mxArray *prhs[4];

20924
          double *pr;

20925
          volatile int_T *intS = (int_T *)&childS;

20926
          int_T addrlen = sizeof(SimStruct *);

20927
          int_T m = addrlen/sizeof(int_T) + 1;

20928
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

20929
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

20930
          pr = mxGetPr(prhs[1]);

20931
          for (i = 0; i < m - 1; i++) {

20932
            pr[i] = (double)intS[i];

20933
          }

20934


20935
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

20936
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

20937
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

20938


20939
          /* Reset port dimensions info functions because the S-function

20940
           * and accelerator mex-files explicitly set their dimensions,

20941
           * i.e., they are not dynamically sized. For this case, the

20942
           * mex-file is responsible for the dimensions info memory

20943
           * and Simulink should not free it. This is achieved by

20944
           * setting the following two methods to NULL.

20945
           */

20946
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

20947
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

20948


20949
          /*

20950
           * Setup function pointers and call mdlInitializeSizes via

20951
           * simulink.c

20952
           */

20953
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

20954
          mxDestroyArray(plhs[0]);

20955
          mxDestroyArray(prhs[0]);

20956
          mxDestroyArray(prhs[1]);

20957
          mxDestroyArray(prhs[2]);

20958
          mxDestroyArray(prhs[3]);

20959
        }

20960


20961
#else

20962


20963
        {

20964
          Gain_sf(childS);

20965
          sfcnInitializeSizes(childS);

20966
        }

20967


20968
#endif

20969


20970
        sfcnInitializeSampleTimes(childS);

20971


20972
        /* adjust sample time */

20973
        ssSetSampleTime(childS, 0, 0.0);

20974
        ssSetOffsetTime(childS, 0, 0.0);

20975
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

20976


20977
        /* set compiled values of dynamic vector attributes */

20978
        ssSetNumNonsampledZCs(childS, 0);

20979


20980
        /* Update connectivity flags for each port */

20981
        _ssSetInputPortConnected(childS, 0, 1);

20982
        _ssSetInputPortConnected(childS, 1, 1);

20983
        _ssSetOutputPortConnected(childS, 0, 1);

20984
        _ssSetOutputPortBeingMerged(childS, 0, 0);

20985


20986
        /* Update the BufferDstPort flags for each input port */

20987
        _ssSetInputPortBufferDstPort(childS, 0, -1);

20988
        _ssSetInputPortBufferDstPort(childS, 1, -1);

20989
      }

20990


20991
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S147>/Generated S-Function (Gain_sf) */

20992
      {

20993
        SimStruct *childS = ssGetSFunction(rts, 79);

20994


20995
        /* timing info */

20996
        time_T *sfcnPeriod;

20997
        time_T *sfcnOffset;

20998
        int_T *sfcnTsMap;

20999
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

21000
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

21001
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

21002
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

21003
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

21004
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

21005
        (void) memset((void*)sfcnPeriod, 0,

21006
                      sizeof(time_T)*1);

21007
        (void) memset((void*)sfcnOffset, 0,

21008
                      sizeof(time_T)*1);

21009
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

21010
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

21011
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

21012


21013
        /* Set up the mdlInfo pointer */

21014
# ifdef USE_RTMODEL

21015


21016
        {

21017
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

21018
              struct _ssBlkInfo2));

21019
          ss_VALIDATE_MEMORY(rts,blkInfo2);

21020
          ssSetBlkInfo2Ptr(childS, blkInfo2);

21021
        }

21022


21023
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

21024


21025
# else

21026


21027
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

21028


21029
# endif                                /* USE_RTMODEL */

21030


21031
        /* Allocate memory of model methods 2 */

21032
        {

21033
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

21034
            malloc(sizeof(struct _ssSFcnModelMethods2));

21035
          ss_VALIDATE_MEMORY(rts,methods2);

21036
          ssSetModelMethods2(childS, methods2);

21037
        }

21038


21039
        /* Allocate memory of model methods 3 */

21040
        {

21041
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

21042
            malloc(sizeof(struct _ssSFcnModelMethods3));

21043
          ss_VALIDATE_MEMORY(rts,methods3);

21044
          ssSetModelMethods3(childS, methods3);

21045
        }

21046


21047
        /* Allocate memory for states auxilliary information */

21048
        {

21049
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

21050
            (sizeof(struct _ssStatesInfo2));

21051
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

21052
            malloc(sizeof(ssPeriodicStatesInfo));

21053
          ss_VALIDATE_MEMORY(rts,statesInfo2);

21054
          ssSetStatesInfo2(childS, statesInfo2);

21055
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

21056
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

21057
        }

21058


21059
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

21060
          RegNumInputPorts);

21061
        ssSetRegNumInputPortsFcnArg(childS,childS);

21062


21063
        /* inputs */

21064
        {

21065
          struct _ssPortInputs *inputPortInfo =

21066
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

21067
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

21068
          _ssSetNumInputPorts(childS, 2);

21069
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

21070


21071
          /* port 0 */

21072
          {

21073
            real32_T const **sfcnUPtrs = (real32_T const **)

21074
              malloc(1 * sizeof(real32_T *));

21075
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21076
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21077
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ma;

21078
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

21079
            _ssSetInputPortNumDimensions(childS, 0, 1);

21080
            ssSetInputPortWidth(childS, 0, 1);

21081
          }

21082


21083
          /* port 1 */

21084
          {

21085
            real32_T const **sfcnUPtrs = (real32_T const **)

21086
              malloc(1 * sizeof(real32_T *));

21087
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21088
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

21089
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

21090
            _ssSetInputPortNumDimensions(childS, 1, 1);

21091
            ssSetInputPortWidth(childS, 1, 1);

21092
          }

21093
        }

21094


21095
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

21096
          RegNumOutputPorts);

21097
        ssSetRegNumOutputPortsFcnArg(childS,childS);

21098


21099
        /* outputs */

21100
        {

21101
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

21102
            calloc(1, sizeof(struct _ssPortOutputs));

21103
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

21104
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

21105
          _ssSetNumOutputPorts(childS, 1);

21106


21107
          /* port 0 */

21108
          {

21109
            _ssSetOutputPortNumDimensions(childS, 0, 1);

21110
            ssSetOutputPortWidth(childS, 0, 1);

21111
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

21112
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ck));

21113
          }

21114
        }

21115


21116
        /* path info */

21117
        _ssSetModelName(childS, "Gain_sf");

21118
        _ssSetPath(childS,

21119
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/gain1/Generated S-Function");

21120
        if (ssGetRTModel(rts) == (NULL)) {

21121
          _ssSetParentSS(childS, rts);

21122
          _ssSetRootSS(childS, ssGetRootSS(rts));

21123
        } else {

21124
          ssSetRTModel(childS,ssGetRTModel(rts));

21125
          _ssSetParentSS(childS, (NULL));

21126
          _ssSetRootSS(childS, childS);

21127
        }

21128


21129
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

21130
        (childS)->regDataType.arg1 = ((void *)(childS));

21131
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

21132
          FcnSetErrorStatus);

21133
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

21134
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

21135
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

21136
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

21137


21138
        /* registration */

21139
#if defined(MATLAB_MEX_FILE)

21140


21141
        {

21142
          int_T i;

21143
          mxArray *plhs[1];

21144
          mxArray *prhs[4];

21145
          double *pr;

21146
          volatile int_T *intS = (int_T *)&childS;

21147
          int_T addrlen = sizeof(SimStruct *);

21148
          int_T m = addrlen/sizeof(int_T) + 1;

21149
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

21150
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

21151
          pr = mxGetPr(prhs[1]);

21152
          for (i = 0; i < m - 1; i++) {

21153
            pr[i] = (double)intS[i];

21154
          }

21155


21156
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

21157
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

21158
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

21159


21160
          /* Reset port dimensions info functions because the S-function

21161
           * and accelerator mex-files explicitly set their dimensions,

21162
           * i.e., they are not dynamically sized. For this case, the

21163
           * mex-file is responsible for the dimensions info memory

21164
           * and Simulink should not free it. This is achieved by

21165
           * setting the following two methods to NULL.

21166
           */

21167
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

21168
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

21169


21170
          /*

21171
           * Setup function pointers and call mdlInitializeSizes via

21172
           * simulink.c

21173
           */

21174
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

21175
          mxDestroyArray(plhs[0]);

21176
          mxDestroyArray(prhs[0]);

21177
          mxDestroyArray(prhs[1]);

21178
          mxDestroyArray(prhs[2]);

21179
          mxDestroyArray(prhs[3]);

21180
        }

21181


21182
#else

21183


21184
        {

21185
          Gain_sf(childS);

21186
          sfcnInitializeSizes(childS);

21187
        }

21188


21189
#endif

21190


21191
        sfcnInitializeSampleTimes(childS);

21192


21193
        /* adjust sample time */

21194
        ssSetSampleTime(childS, 0, 0.0);

21195
        ssSetOffsetTime(childS, 0, 0.0);

21196
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

21197


21198
        /* set compiled values of dynamic vector attributes */

21199
        ssSetNumNonsampledZCs(childS, 0);

21200


21201
        /* Update connectivity flags for each port */

21202
        _ssSetInputPortConnected(childS, 0, 1);

21203
        _ssSetInputPortConnected(childS, 1, 1);

21204
        _ssSetOutputPortConnected(childS, 0, 1);

21205
        _ssSetOutputPortBeingMerged(childS, 0, 0);

21206


21207
        /* Update the BufferDstPort flags for each input port */

21208
        _ssSetInputPortBufferDstPort(childS, 0, -1);

21209
        _ssSetInputPortBufferDstPort(childS, 1, -1);

21210
      }

21211


21212
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S140>/Generated S-Function3 (IntegratorLimited_sf) */

21213
      {

21214
        SimStruct *childS = ssGetSFunction(rts, 80);

21215


21216
        /* timing info */

21217
        time_T *sfcnPeriod;

21218
        time_T *sfcnOffset;

21219
        int_T *sfcnTsMap;

21220
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

21221
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

21222
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

21223
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

21224
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

21225
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

21226
        (void) memset((void*)sfcnPeriod, 0,

21227
                      sizeof(time_T)*1);

21228
        (void) memset((void*)sfcnOffset, 0,

21229
                      sizeof(time_T)*1);

21230
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

21231
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

21232
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

21233


21234
        /* Set up the mdlInfo pointer */

21235
# ifdef USE_RTMODEL

21236


21237
        {

21238
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

21239
              struct _ssBlkInfo2));

21240
          ss_VALIDATE_MEMORY(rts,blkInfo2);

21241
          ssSetBlkInfo2Ptr(childS, blkInfo2);

21242
        }

21243


21244
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

21245


21246
# else

21247


21248
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

21249


21250
# endif                                /* USE_RTMODEL */

21251


21252
        /* Allocate memory of model methods 2 */

21253
        {

21254
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

21255
            malloc(sizeof(struct _ssSFcnModelMethods2));

21256
          ss_VALIDATE_MEMORY(rts,methods2);

21257
          ssSetModelMethods2(childS, methods2);

21258
        }

21259


21260
        /* Allocate memory of model methods 3 */

21261
        {

21262
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

21263
            malloc(sizeof(struct _ssSFcnModelMethods3));

21264
          ss_VALIDATE_MEMORY(rts,methods3);

21265
          ssSetModelMethods3(childS, methods3);

21266
        }

21267


21268
        /* Allocate memory for states auxilliary information */

21269
        {

21270
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

21271
            (sizeof(struct _ssStatesInfo2));

21272
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

21273
            malloc(sizeof(ssPeriodicStatesInfo));

21274
          ss_VALIDATE_MEMORY(rts,statesInfo2);

21275
          ssSetStatesInfo2(childS, statesInfo2);

21276
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

21277
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

21278
        }

21279


21280
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

21281
          RegNumInputPorts);

21282
        ssSetRegNumInputPortsFcnArg(childS,childS);

21283


21284
        /* inputs */

21285
        {

21286
          struct _ssPortInputs *inputPortInfo =

21287
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

21288
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

21289
          _ssSetNumInputPorts(childS, 7);

21290
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

21291


21292
          /* port 0 */

21293
          {

21294
            real32_T const **sfcnUPtrs = (real32_T const **)

21295
              malloc(1 * sizeof(real32_T *));

21296
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21297
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21298
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

21299
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

21300
            _ssSetInputPortNumDimensions(childS, 0, 1);

21301
            ssSetInputPortWidth(childS, 0, 1);

21302
          }

21303


21304
          /* port 1 */

21305
          {

21306
            int8_T const **sfcnUPtrs = (int8_T const **)

21307
              malloc(1 * sizeof(int8_T *));

21308
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21309
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

21310
              ssGetLocalBlockIO(rts))->DataTypeConversion2_p;

21311
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

21312
            _ssSetInputPortNumDimensions(childS, 1, 1);

21313
            ssSetInputPortWidth(childS, 1, 1);

21314
          }

21315


21316
          /* port 2 */

21317
          {

21318
            real32_T const **sfcnUPtrs = (real32_T const **)

21319
              malloc(1 * sizeof(real32_T *));

21320
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21321
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

21322
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

21323
            _ssSetInputPortNumDimensions(childS, 2, 1);

21324
            ssSetInputPortWidth(childS, 2, 1);

21325
          }

21326


21327
          /* port 3 */

21328
          {

21329
            real32_T const **sfcnUPtrs = (real32_T const **)

21330
              malloc(1 * sizeof(real32_T *));

21331
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21332
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

21333
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

21334
            _ssSetInputPortNumDimensions(childS, 3, 1);

21335
            ssSetInputPortWidth(childS, 3, 1);

21336
          }

21337


21338
          /* port 4 */

21339
          {

21340
            real32_T const **sfcnUPtrs = (real32_T const **)

21341
              malloc(1 * sizeof(real32_T *));

21342
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21343
            sfcnUPtrs[0] = (real32_T const *)

21344
              &AFCS_MODEL1_ConstP.Constant29_Value;

21345
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

21346
            _ssSetInputPortNumDimensions(childS, 4, 1);

21347
            ssSetInputPortWidth(childS, 4, 1);

21348
          }

21349


21350
          /* port 5 */

21351
          {

21352
            real32_T const **sfcnUPtrs = (real32_T const **)

21353
              malloc(1 * sizeof(real32_T *));

21354
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21355
            sfcnUPtrs[0] = (real32_T const *)

21356
              &AFCS_MODEL1_ConstP.Constant30_Value;

21357
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

21358
            _ssSetInputPortNumDimensions(childS, 5, 1);

21359
            ssSetInputPortWidth(childS, 5, 1);

21360
          }

21361


21362
          /* port 6 */

21363
          {

21364
            real32_T const **sfcnUPtrs = (real32_T const **)

21365
              malloc(1 * sizeof(real32_T *));

21366
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21367
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21368
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ck;

21369
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

21370
            _ssSetInputPortNumDimensions(childS, 6, 1);

21371
            ssSetInputPortWidth(childS, 6, 1);

21372
          }

21373
        }

21374


21375
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

21376
          RegNumOutputPorts);

21377
        ssSetRegNumOutputPortsFcnArg(childS,childS);

21378


21379
        /* outputs */

21380
        {

21381
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

21382
            calloc(1, sizeof(struct _ssPortOutputs));

21383
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

21384
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

21385
          _ssSetNumOutputPorts(childS, 1);

21386


21387
          /* port 0 */

21388
          {

21389
            _ssSetOutputPortNumDimensions(childS, 0, 1);

21390
            ssSetOutputPortWidth(childS, 0, 1);

21391
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

21392
              ssGetLocalBlockIO(rts))->Saturation2_p));

21393
          }

21394
        }

21395


21396
        /* path info */

21397
        _ssSetModelName(childS, "IntegratorLimited_sf");

21398
        _ssSetPath(childS,

21399
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Integrator Limited/Generated S-Function3");

21400
        if (ssGetRTModel(rts) == (NULL)) {

21401
          _ssSetParentSS(childS, rts);

21402
          _ssSetRootSS(childS, ssGetRootSS(rts));

21403
        } else {

21404
          ssSetRTModel(childS,ssGetRTModel(rts));

21405
          _ssSetParentSS(childS, (NULL));

21406
          _ssSetRootSS(childS, childS);

21407
        }

21408


21409
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

21410


21411
        /* work vectors */

21412
        {

21413
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

21414
            (4 * sizeof(struct _ssDWorkRecord));

21415
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

21416
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

21417
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

21418
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

21419
          ssSetSFcnDWork(childS, dWorkRecord);

21420
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

21421
          _ssSetNumDWork(childS, 4);

21422


21423
          /* DWORK0 */

21424
          ssSetDWorkWidth(childS, 0, 1);

21425
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

21426
          ssSetDWorkComplexSignal(childS, 0, 0);

21427
          ssSetDWorkUsedAsDState(childS, 0, 1);

21428
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 208))[0]);

21429


21430
          /* DWORK1 */

21431
          ssSetDWorkWidth(childS, 1, 1);

21432
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

21433
          ssSetDWorkComplexSignal(childS, 1, 0);

21434
          ssSetDWorkUsedAsDState(childS, 1, 1);

21435
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 209))[0]);

21436


21437
          /* DWORK2 */

21438
          ssSetDWorkWidth(childS, 2, 1);

21439
          ssSetDWorkDataType(childS, 2,SS_INT8);

21440
          ssSetDWorkComplexSignal(childS, 2, 0);

21441
          ssSetDWorkUsedAsDState(childS, 2, 1);

21442
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 435))[0]);

21443


21444
          /* DWORK3 */

21445
          ssSetDWorkWidth(childS, 3, 1);

21446
          ssSetDWorkDataType(childS, 3,SS_INT8);

21447
          ssSetDWorkComplexSignal(childS, 3, 0);

21448
          ssSetDWorkUsedAsDState(childS, 3, 1);

21449
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 436))[0]);

21450
        }

21451


21452
        (childS)->regDataType.arg1 = ((void *)(childS));

21453
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

21454
          FcnSetErrorStatus);

21455
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

21456
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

21457
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

21458
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

21459


21460
        /* registration */

21461
#if defined(MATLAB_MEX_FILE)

21462


21463
        {

21464
          int_T i;

21465
          mxArray *plhs[1];

21466
          mxArray *prhs[4];

21467
          double *pr;

21468
          volatile int_T *intS = (int_T *)&childS;

21469
          int_T addrlen = sizeof(SimStruct *);

21470
          int_T m = addrlen/sizeof(int_T) + 1;

21471
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

21472
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

21473
          pr = mxGetPr(prhs[1]);

21474
          for (i = 0; i < m - 1; i++) {

21475
            pr[i] = (double)intS[i];

21476
          }

21477


21478
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

21479
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

21480
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

21481


21482
          /* Reset port dimensions info functions because the S-function

21483
           * and accelerator mex-files explicitly set their dimensions,

21484
           * i.e., they are not dynamically sized. For this case, the

21485
           * mex-file is responsible for the dimensions info memory

21486
           * and Simulink should not free it. This is achieved by

21487
           * setting the following two methods to NULL.

21488
           */

21489
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

21490
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

21491


21492
          /*

21493
           * Setup function pointers and call mdlInitializeSizes via

21494
           * simulink.c

21495
           */

21496
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

21497
          mxDestroyArray(plhs[0]);

21498
          mxDestroyArray(prhs[0]);

21499
          mxDestroyArray(prhs[1]);

21500
          mxDestroyArray(prhs[2]);

21501
          mxDestroyArray(prhs[3]);

21502
        }

21503


21504
#else

21505


21506
        {

21507
          IntegratorLimited_sf(childS);

21508
          sfcnInitializeSizes(childS);

21509
        }

21510


21511
#endif

21512


21513
        sfcnInitializeSampleTimes(childS);

21514


21515
        /* adjust sample time */

21516
        ssSetSampleTime(childS, 0, 0.0);

21517
        ssSetOffsetTime(childS, 0, 0.0);

21518
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

21519


21520
        /* set compiled values of dynamic vector attributes */

21521
        ssSetNumNonsampledZCs(childS, 0);

21522


21523
        /* Update connectivity flags for each port */

21524
        _ssSetInputPortConnected(childS, 0, 1);

21525
        _ssSetInputPortConnected(childS, 1, 1);

21526
        _ssSetInputPortConnected(childS, 2, 1);

21527
        _ssSetInputPortConnected(childS, 3, 1);

21528
        _ssSetInputPortConnected(childS, 4, 1);

21529
        _ssSetInputPortConnected(childS, 5, 1);

21530
        _ssSetInputPortConnected(childS, 6, 1);

21531
        _ssSetOutputPortConnected(childS, 0, 1);

21532
        _ssSetOutputPortBeingMerged(childS, 0, 0);

21533


21534
        /* Update the BufferDstPort flags for each input port */

21535
        _ssSetInputPortBufferDstPort(childS, 0, -1);

21536
        _ssSetInputPortBufferDstPort(childS, 1, -1);

21537
        _ssSetInputPortBufferDstPort(childS, 2, -1);

21538
        _ssSetInputPortBufferDstPort(childS, 3, -1);

21539
        _ssSetInputPortBufferDstPort(childS, 4, -1);

21540
        _ssSetInputPortBufferDstPort(childS, 5, -1);

21541
        _ssSetInputPortBufferDstPort(childS, 6, -1);

21542
      }

21543


21544
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S141>/Generated S-Function2 (LeadLagFilter_sf) */

21545
      {

21546
        SimStruct *childS = ssGetSFunction(rts, 81);

21547


21548
        /* timing info */

21549
        time_T *sfcnPeriod;

21550
        time_T *sfcnOffset;

21551
        int_T *sfcnTsMap;

21552
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

21553
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

21554
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

21555
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

21556
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

21557
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

21558
        (void) memset((void*)sfcnPeriod, 0,

21559
                      sizeof(time_T)*1);

21560
        (void) memset((void*)sfcnOffset, 0,

21561
                      sizeof(time_T)*1);

21562
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

21563
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

21564
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

21565


21566
        /* Set up the mdlInfo pointer */

21567
# ifdef USE_RTMODEL

21568


21569
        {

21570
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

21571
              struct _ssBlkInfo2));

21572
          ss_VALIDATE_MEMORY(rts,blkInfo2);

21573
          ssSetBlkInfo2Ptr(childS, blkInfo2);

21574
        }

21575


21576
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

21577


21578
# else

21579


21580
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

21581


21582
# endif                                /* USE_RTMODEL */

21583


21584
        /* Allocate memory of model methods 2 */

21585
        {

21586
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

21587
            malloc(sizeof(struct _ssSFcnModelMethods2));

21588
          ss_VALIDATE_MEMORY(rts,methods2);

21589
          ssSetModelMethods2(childS, methods2);

21590
        }

21591


21592
        /* Allocate memory of model methods 3 */

21593
        {

21594
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

21595
            malloc(sizeof(struct _ssSFcnModelMethods3));

21596
          ss_VALIDATE_MEMORY(rts,methods3);

21597
          ssSetModelMethods3(childS, methods3);

21598
        }

21599


21600
        /* Allocate memory for states auxilliary information */

21601
        {

21602
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

21603
            (sizeof(struct _ssStatesInfo2));

21604
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

21605
            malloc(sizeof(ssPeriodicStatesInfo));

21606
          ss_VALIDATE_MEMORY(rts,statesInfo2);

21607
          ssSetStatesInfo2(childS, statesInfo2);

21608
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

21609
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

21610
        }

21611


21612
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

21613
          RegNumInputPorts);

21614
        ssSetRegNumInputPortsFcnArg(childS,childS);

21615


21616
        /* inputs */

21617
        {

21618
          struct _ssPortInputs *inputPortInfo =

21619
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

21620
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

21621
          _ssSetNumInputPorts(childS, 7);

21622
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

21623


21624
          /* port 0 */

21625
          {

21626
            real32_T const **sfcnUPtrs = (real32_T const **)

21627
              malloc(1 * sizeof(real32_T *));

21628
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21629
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21630
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

21631
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

21632
            _ssSetInputPortNumDimensions(childS, 0, 1);

21633
            ssSetInputPortWidth(childS, 0, 1);

21634
          }

21635


21636
          /* port 1 */

21637
          {

21638
            int8_T const **sfcnUPtrs = (int8_T const **)

21639
              malloc(1 * sizeof(int8_T *));

21640
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21641
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

21642
              ssGetLocalBlockIO(rts))->DataTypeConversion2_p;

21643
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

21644
            _ssSetInputPortNumDimensions(childS, 1, 1);

21645
            ssSetInputPortWidth(childS, 1, 1);

21646
          }

21647


21648
          /* port 2 */

21649
          {

21650
            real32_T const **sfcnUPtrs = (real32_T const **)

21651
              malloc(1 * sizeof(real32_T *));

21652
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21653
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

21654
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

21655
            _ssSetInputPortNumDimensions(childS, 2, 1);

21656
            ssSetInputPortWidth(childS, 2, 1);

21657
          }

21658


21659
          /* port 3 */

21660
          {

21661
            real32_T const **sfcnUPtrs = (real32_T const **)

21662
              malloc(1 * sizeof(real32_T *));

21663
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21664
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

21665
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

21666
            _ssSetInputPortNumDimensions(childS, 3, 1);

21667
            ssSetInputPortWidth(childS, 3, 1);

21668
          }

21669


21670
          /* port 4 */

21671
          {

21672
            real32_T const **sfcnUPtrs = (real32_T const **)

21673
              malloc(1 * sizeof(real32_T *));

21674
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21675
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21676
              ssGetLocalBlockIO(rts))->Switch_bg;

21677
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

21678
            _ssSetInputPortNumDimensions(childS, 4, 1);

21679
            ssSetInputPortWidth(childS, 4, 1);

21680
          }

21681


21682
          /* port 5 */

21683
          {

21684
            real32_T const **sfcnUPtrs = (real32_T const **)

21685
              malloc(1 * sizeof(real32_T *));

21686
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21687
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21688
              ssGetLocalBlockIO(rts))->Switch_bg;

21689
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

21690
            _ssSetInputPortNumDimensions(childS, 5, 1);

21691
            ssSetInputPortWidth(childS, 5, 1);

21692
          }

21693


21694
          /* port 6 */

21695
          {

21696
            real32_T const **sfcnUPtrs = (real32_T const **)

21697
              malloc(1 * sizeof(real32_T *));

21698
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21699
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21700
              ssGetLocalBlockIO(rts))->Sum_mz;

21701
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

21702
            _ssSetInputPortNumDimensions(childS, 6, 1);

21703
            ssSetInputPortWidth(childS, 6, 1);

21704
          }

21705
        }

21706


21707
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

21708
          RegNumOutputPorts);

21709
        ssSetRegNumOutputPortsFcnArg(childS,childS);

21710


21711
        /* outputs */

21712
        {

21713
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

21714
            calloc(1, sizeof(struct _ssPortOutputs));

21715
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

21716
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

21717
          _ssSetNumOutputPorts(childS, 1);

21718


21719
          /* port 0 */

21720
          {

21721
            _ssSetOutputPortNumDimensions(childS, 0, 1);

21722
            ssSetOutputPortWidth(childS, 0, 1);

21723
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

21724
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_n));

21725
          }

21726
        }

21727


21728
        /* path info */

21729
        _ssSetModelName(childS, "LeadLagFilter_sf");

21730
        _ssSetPath(childS,

21731
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Lead lag/Generated S-Function2");

21732
        if (ssGetRTModel(rts) == (NULL)) {

21733
          _ssSetParentSS(childS, rts);

21734
          _ssSetRootSS(childS, ssGetRootSS(rts));

21735
        } else {

21736
          ssSetRTModel(childS,ssGetRTModel(rts));

21737
          _ssSetParentSS(childS, (NULL));

21738
          _ssSetRootSS(childS, childS);

21739
        }

21740


21741
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

21742


21743
        /* work vectors */

21744
        {

21745
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

21746
            (4 * sizeof(struct _ssDWorkRecord));

21747
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

21748
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

21749
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

21750
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

21751
          ssSetSFcnDWork(childS, dWorkRecord);

21752
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

21753
          _ssSetNumDWork(childS, 4);

21754


21755
          /* DWORK0 */

21756
          ssSetDWorkWidth(childS, 0, 1);

21757
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

21758
          ssSetDWorkComplexSignal(childS, 0, 0);

21759
          ssSetDWorkUsedAsDState(childS, 0, 1);

21760
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 210))[0]);

21761


21762
          /* DWORK1 */

21763
          ssSetDWorkWidth(childS, 1, 1);

21764
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

21765
          ssSetDWorkComplexSignal(childS, 1, 0);

21766
          ssSetDWorkUsedAsDState(childS, 1, 1);

21767
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 211))[0]);

21768


21769
          /* DWORK2 */

21770
          ssSetDWorkWidth(childS, 2, 1);

21771
          ssSetDWorkDataType(childS, 2,SS_INT8);

21772
          ssSetDWorkComplexSignal(childS, 2, 0);

21773
          ssSetDWorkUsedAsDState(childS, 2, 1);

21774
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 437))[0]);

21775


21776
          /* DWORK3 */

21777
          ssSetDWorkWidth(childS, 3, 1);

21778
          ssSetDWorkDataType(childS, 3,SS_INT8);

21779
          ssSetDWorkComplexSignal(childS, 3, 0);

21780
          ssSetDWorkUsedAsDState(childS, 3, 1);

21781
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 438))[0]);

21782
        }

21783


21784
        (childS)->regDataType.arg1 = ((void *)(childS));

21785
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

21786
          FcnSetErrorStatus);

21787
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

21788
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

21789
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

21790
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

21791


21792
        /* registration */

21793
#if defined(MATLAB_MEX_FILE)

21794


21795
        {

21796
          int_T i;

21797
          mxArray *plhs[1];

21798
          mxArray *prhs[4];

21799
          double *pr;

21800
          volatile int_T *intS = (int_T *)&childS;

21801
          int_T addrlen = sizeof(SimStruct *);

21802
          int_T m = addrlen/sizeof(int_T) + 1;

21803
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

21804
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

21805
          pr = mxGetPr(prhs[1]);

21806
          for (i = 0; i < m - 1; i++) {

21807
            pr[i] = (double)intS[i];

21808
          }

21809


21810
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

21811
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

21812
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

21813


21814
          /* Reset port dimensions info functions because the S-function

21815
           * and accelerator mex-files explicitly set their dimensions,

21816
           * i.e., they are not dynamically sized. For this case, the

21817
           * mex-file is responsible for the dimensions info memory

21818
           * and Simulink should not free it. This is achieved by

21819
           * setting the following two methods to NULL.

21820
           */

21821
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

21822
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

21823


21824
          /*

21825
           * Setup function pointers and call mdlInitializeSizes via

21826
           * simulink.c

21827
           */

21828
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

21829
          mxDestroyArray(plhs[0]);

21830
          mxDestroyArray(prhs[0]);

21831
          mxDestroyArray(prhs[1]);

21832
          mxDestroyArray(prhs[2]);

21833
          mxDestroyArray(prhs[3]);

21834
        }

21835


21836
#else

21837


21838
        {

21839
          LeadLagFilter_sf(childS);

21840
          sfcnInitializeSizes(childS);

21841
        }

21842


21843
#endif

21844


21845
        sfcnInitializeSampleTimes(childS);

21846


21847
        /* adjust sample time */

21848
        ssSetSampleTime(childS, 0, 0.0);

21849
        ssSetOffsetTime(childS, 0, 0.0);

21850
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

21851


21852
        /* set compiled values of dynamic vector attributes */

21853
        ssSetNumNonsampledZCs(childS, 0);

21854


21855
        /* Update connectivity flags for each port */

21856
        _ssSetInputPortConnected(childS, 0, 1);

21857
        _ssSetInputPortConnected(childS, 1, 1);

21858
        _ssSetInputPortConnected(childS, 2, 1);

21859
        _ssSetInputPortConnected(childS, 3, 1);

21860
        _ssSetInputPortConnected(childS, 4, 1);

21861
        _ssSetInputPortConnected(childS, 5, 1);

21862
        _ssSetInputPortConnected(childS, 6, 1);

21863
        _ssSetOutputPortConnected(childS, 0, 1);

21864
        _ssSetOutputPortBeingMerged(childS, 0, 0);

21865


21866
        /* Update the BufferDstPort flags for each input port */

21867
        _ssSetInputPortBufferDstPort(childS, 0, -1);

21868
        _ssSetInputPortBufferDstPort(childS, 1, -1);

21869
        _ssSetInputPortBufferDstPort(childS, 2, -1);

21870
        _ssSetInputPortBufferDstPort(childS, 3, -1);

21871
        _ssSetInputPortBufferDstPort(childS, 4, -1);

21872
        _ssSetInputPortBufferDstPort(childS, 5, -1);

21873
        _ssSetInputPortBufferDstPort(childS, 6, -1);

21874
      }

21875


21876
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S139>/Generated S-Function4 (LagFilter_sf) */

21877
      {

21878
        SimStruct *childS = ssGetSFunction(rts, 82);

21879


21880
        /* timing info */

21881
        time_T *sfcnPeriod;

21882
        time_T *sfcnOffset;

21883
        int_T *sfcnTsMap;

21884
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

21885
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

21886
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

21887
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

21888
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

21889
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

21890
        (void) memset((void*)sfcnPeriod, 0,

21891
                      sizeof(time_T)*1);

21892
        (void) memset((void*)sfcnOffset, 0,

21893
                      sizeof(time_T)*1);

21894
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

21895
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

21896
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

21897


21898
        /* Set up the mdlInfo pointer */

21899
# ifdef USE_RTMODEL

21900


21901
        {

21902
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

21903
              struct _ssBlkInfo2));

21904
          ss_VALIDATE_MEMORY(rts,blkInfo2);

21905
          ssSetBlkInfo2Ptr(childS, blkInfo2);

21906
        }

21907


21908
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

21909


21910
# else

21911


21912
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

21913


21914
# endif                                /* USE_RTMODEL */

21915


21916
        /* Allocate memory of model methods 2 */

21917
        {

21918
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

21919
            malloc(sizeof(struct _ssSFcnModelMethods2));

21920
          ss_VALIDATE_MEMORY(rts,methods2);

21921
          ssSetModelMethods2(childS, methods2);

21922
        }

21923


21924
        /* Allocate memory of model methods 3 */

21925
        {

21926
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

21927
            malloc(sizeof(struct _ssSFcnModelMethods3));

21928
          ss_VALIDATE_MEMORY(rts,methods3);

21929
          ssSetModelMethods3(childS, methods3);

21930
        }

21931


21932
        /* Allocate memory for states auxilliary information */

21933
        {

21934
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

21935
            (sizeof(struct _ssStatesInfo2));

21936
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

21937
            malloc(sizeof(ssPeriodicStatesInfo));

21938
          ss_VALIDATE_MEMORY(rts,statesInfo2);

21939
          ssSetStatesInfo2(childS, statesInfo2);

21940
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

21941
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

21942
        }

21943


21944
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

21945
          RegNumInputPorts);

21946
        ssSetRegNumInputPortsFcnArg(childS,childS);

21947


21948
        /* inputs */

21949
        {

21950
          struct _ssPortInputs *inputPortInfo =

21951
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

21952
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

21953
          _ssSetNumInputPorts(childS, 6);

21954
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

21955


21956
          /* port 0 */

21957
          {

21958
            real32_T const **sfcnUPtrs = (real32_T const **)

21959
              malloc(1 * sizeof(real32_T *));

21960
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21961
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21962
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

21963
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

21964
            _ssSetInputPortNumDimensions(childS, 0, 1);

21965
            ssSetInputPortWidth(childS, 0, 1);

21966
          }

21967


21968
          /* port 1 */

21969
          {

21970
            int8_T const **sfcnUPtrs = (int8_T const **)

21971
              malloc(1 * sizeof(int8_T *));

21972
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21973
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

21974
              ssGetLocalBlockIO(rts))->DataTypeConversion2_p;

21975
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

21976
            _ssSetInputPortNumDimensions(childS, 1, 1);

21977
            ssSetInputPortWidth(childS, 1, 1);

21978
          }

21979


21980
          /* port 2 */

21981
          {

21982
            real32_T const **sfcnUPtrs = (real32_T const **)

21983
              malloc(1 * sizeof(real32_T *));

21984
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21985
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

21986
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

21987
            _ssSetInputPortNumDimensions(childS, 2, 1);

21988
            ssSetInputPortWidth(childS, 2, 1);

21989
          }

21990


21991
          /* port 3 */

21992
          {

21993
            real32_T const **sfcnUPtrs = (real32_T const **)

21994
              malloc(1 * sizeof(real32_T *));

21995
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

21996
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

21997
              ssGetLocalBlockIO(rts))->Switch_bg;

21998
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

21999
            _ssSetInputPortNumDimensions(childS, 3, 1);

22000
            ssSetInputPortWidth(childS, 3, 1);

22001
          }

22002


22003
          /* port 4 */

22004
          {

22005
            real32_T const **sfcnUPtrs = (real32_T const **)

22006
              malloc(1 * sizeof(real32_T *));

22007
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22008
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

22009
              ssGetLocalBlockIO(rts))->Switch_bg;

22010
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

22011
            _ssSetInputPortNumDimensions(childS, 4, 1);

22012
            ssSetInputPortWidth(childS, 4, 1);

22013
          }

22014


22015
          /* port 5 */

22016
          {

22017
            real32_T const **sfcnUPtrs = (real32_T const **)

22018
              malloc(1 * sizeof(real32_T *));

22019
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22020
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

22021
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_n;

22022
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

22023
            _ssSetInputPortNumDimensions(childS, 5, 1);

22024
            ssSetInputPortWidth(childS, 5, 1);

22025
          }

22026
        }

22027


22028
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

22029
          RegNumOutputPorts);

22030
        ssSetRegNumOutputPortsFcnArg(childS,childS);

22031


22032
        /* outputs */

22033
        {

22034
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

22035
            calloc(1, sizeof(struct _ssPortOutputs));

22036
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

22037
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

22038
          _ssSetNumOutputPorts(childS, 1);

22039


22040
          /* port 0 */

22041
          {

22042
            _ssSetOutputPortNumDimensions(childS, 0, 1);

22043
            ssSetOutputPortWidth(childS, 0, 1);

22044
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

22045
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_cg));

22046
          }

22047
        }

22048


22049
        /* path info */

22050
        _ssSetModelName(childS, "LagFilter_sf");

22051
        _ssSetPath(childS,

22052
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/ lag filter/Generated S-Function4");

22053
        if (ssGetRTModel(rts) == (NULL)) {

22054
          _ssSetParentSS(childS, rts);

22055
          _ssSetRootSS(childS, ssGetRootSS(rts));

22056
        } else {

22057
          ssSetRTModel(childS,ssGetRTModel(rts));

22058
          _ssSetParentSS(childS, (NULL));

22059
          _ssSetRootSS(childS, childS);

22060
        }

22061


22062
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

22063


22064
        /* work vectors */

22065
        {

22066
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

22067
            (4 * sizeof(struct _ssDWorkRecord));

22068
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

22069
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

22070
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

22071
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

22072
          ssSetSFcnDWork(childS, dWorkRecord);

22073
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

22074
          _ssSetNumDWork(childS, 4);

22075


22076
          /* DWORK0 */

22077
          ssSetDWorkWidth(childS, 0, 1);

22078
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

22079
          ssSetDWorkComplexSignal(childS, 0, 0);

22080
          ssSetDWorkUsedAsDState(childS, 0, 1);

22081
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 212))[0]);

22082


22083
          /* DWORK1 */

22084
          ssSetDWorkWidth(childS, 1, 1);

22085
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

22086
          ssSetDWorkComplexSignal(childS, 1, 0);

22087
          ssSetDWorkUsedAsDState(childS, 1, 1);

22088
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 213))[0]);

22089


22090
          /* DWORK2 */

22091
          ssSetDWorkWidth(childS, 2, 1);

22092
          ssSetDWorkDataType(childS, 2,SS_INT8);

22093
          ssSetDWorkComplexSignal(childS, 2, 0);

22094
          ssSetDWorkUsedAsDState(childS, 2, 1);

22095
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 439))[0]);

22096


22097
          /* DWORK3 */

22098
          ssSetDWorkWidth(childS, 3, 1);

22099
          ssSetDWorkDataType(childS, 3,SS_INT8);

22100
          ssSetDWorkComplexSignal(childS, 3, 0);

22101
          ssSetDWorkUsedAsDState(childS, 3, 1);

22102
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 440))[0]);

22103
        }

22104


22105
        (childS)->regDataType.arg1 = ((void *)(childS));

22106
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

22107
          FcnSetErrorStatus);

22108
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

22109
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

22110
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

22111
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

22112


22113
        /* registration */

22114
#if defined(MATLAB_MEX_FILE)

22115


22116
        {

22117
          int_T i;

22118
          mxArray *plhs[1];

22119
          mxArray *prhs[4];

22120
          double *pr;

22121
          volatile int_T *intS = (int_T *)&childS;

22122
          int_T addrlen = sizeof(SimStruct *);

22123
          int_T m = addrlen/sizeof(int_T) + 1;

22124
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

22125
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

22126
          pr = mxGetPr(prhs[1]);

22127
          for (i = 0; i < m - 1; i++) {

22128
            pr[i] = (double)intS[i];

22129
          }

22130


22131
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

22132
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

22133
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

22134


22135
          /* Reset port dimensions info functions because the S-function

22136
           * and accelerator mex-files explicitly set their dimensions,

22137
           * i.e., they are not dynamically sized. For this case, the

22138
           * mex-file is responsible for the dimensions info memory

22139
           * and Simulink should not free it. This is achieved by

22140
           * setting the following two methods to NULL.

22141
           */

22142
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

22143
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

22144


22145
          /*

22146
           * Setup function pointers and call mdlInitializeSizes via

22147
           * simulink.c

22148
           */

22149
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

22150
          mxDestroyArray(plhs[0]);

22151
          mxDestroyArray(prhs[0]);

22152
          mxDestroyArray(prhs[1]);

22153
          mxDestroyArray(prhs[2]);

22154
          mxDestroyArray(prhs[3]);

22155
        }

22156


22157
#else

22158


22159
        {

22160
          LagFilter_sf(childS);

22161
          sfcnInitializeSizes(childS);

22162
        }

22163


22164
#endif

22165


22166
        sfcnInitializeSampleTimes(childS);

22167


22168
        /* adjust sample time */

22169
        ssSetSampleTime(childS, 0, 0.0);

22170
        ssSetOffsetTime(childS, 0, 0.0);

22171
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

22172


22173
        /* set compiled values of dynamic vector attributes */

22174
        ssSetNumNonsampledZCs(childS, 0);

22175


22176
        /* Update connectivity flags for each port */

22177
        _ssSetInputPortConnected(childS, 0, 1);

22178
        _ssSetInputPortConnected(childS, 1, 1);

22179
        _ssSetInputPortConnected(childS, 2, 1);

22180
        _ssSetInputPortConnected(childS, 3, 1);

22181
        _ssSetInputPortConnected(childS, 4, 1);

22182
        _ssSetInputPortConnected(childS, 5, 1);

22183
        _ssSetOutputPortConnected(childS, 0, 1);

22184
        _ssSetOutputPortBeingMerged(childS, 0, 0);

22185


22186
        /* Update the BufferDstPort flags for each input port */

22187
        _ssSetInputPortBufferDstPort(childS, 0, -1);

22188
        _ssSetInputPortBufferDstPort(childS, 1, -1);

22189
        _ssSetInputPortBufferDstPort(childS, 2, -1);

22190
        _ssSetInputPortBufferDstPort(childS, 3, -1);

22191
        _ssSetInputPortBufferDstPort(childS, 4, -1);

22192
        _ssSetInputPortBufferDstPort(childS, 5, -1);

22193
      }

22194


22195
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S164>/Generated S-Function1 (SaturationLimiter_sf) */

22196
      {

22197
        SimStruct *childS = ssGetSFunction(rts, 83);

22198


22199
        /* timing info */

22200
        time_T *sfcnPeriod;

22201
        time_T *sfcnOffset;

22202
        int_T *sfcnTsMap;

22203
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

22204
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

22205
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

22206
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

22207
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

22208
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

22209
        (void) memset((void*)sfcnPeriod, 0,

22210
                      sizeof(time_T)*1);

22211
        (void) memset((void*)sfcnOffset, 0,

22212
                      sizeof(time_T)*1);

22213
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

22214
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

22215
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

22216


22217
        /* Set up the mdlInfo pointer */

22218
# ifdef USE_RTMODEL

22219


22220
        {

22221
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

22222
              struct _ssBlkInfo2));

22223
          ss_VALIDATE_MEMORY(rts,blkInfo2);

22224
          ssSetBlkInfo2Ptr(childS, blkInfo2);

22225
        }

22226


22227
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

22228


22229
# else

22230


22231
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

22232


22233
# endif                                /* USE_RTMODEL */

22234


22235
        /* Allocate memory of model methods 2 */

22236
        {

22237
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

22238
            malloc(sizeof(struct _ssSFcnModelMethods2));

22239
          ss_VALIDATE_MEMORY(rts,methods2);

22240
          ssSetModelMethods2(childS, methods2);

22241
        }

22242


22243
        /* Allocate memory of model methods 3 */

22244
        {

22245
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

22246
            malloc(sizeof(struct _ssSFcnModelMethods3));

22247
          ss_VALIDATE_MEMORY(rts,methods3);

22248
          ssSetModelMethods3(childS, methods3);

22249
        }

22250


22251
        /* Allocate memory for states auxilliary information */

22252
        {

22253
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

22254
            (sizeof(struct _ssStatesInfo2));

22255
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

22256
            malloc(sizeof(ssPeriodicStatesInfo));

22257
          ss_VALIDATE_MEMORY(rts,statesInfo2);

22258
          ssSetStatesInfo2(childS, statesInfo2);

22259
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

22260
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

22261
        }

22262


22263
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

22264
          RegNumInputPorts);

22265
        ssSetRegNumInputPortsFcnArg(childS,childS);

22266


22267
        /* inputs */

22268
        {

22269
          struct _ssPortInputs *inputPortInfo =

22270
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

22271
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

22272
          _ssSetNumInputPorts(childS, 3);

22273
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

22274


22275
          /* port 0 */

22276
          {

22277
            real32_T const **sfcnUPtrs = (real32_T const **)

22278
              malloc(1 * sizeof(real32_T *));

22279
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22280
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

22281
              ssGetLocalBlockIO(rts))->Sum2_hh;

22282
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

22283
            _ssSetInputPortNumDimensions(childS, 0, 1);

22284
            ssSetInputPortWidth(childS, 0, 1);

22285
          }

22286


22287
          /* port 1 */

22288
          {

22289
            real32_T const **sfcnUPtrs = (real32_T const **)

22290
              malloc(1 * sizeof(real32_T *));

22291
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22292
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;

22293
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

22294
            _ssSetInputPortNumDimensions(childS, 1, 1);

22295
            ssSetInputPortWidth(childS, 1, 1);

22296
          }

22297


22298
          /* port 2 */

22299
          {

22300
            real32_T const **sfcnUPtrs = (real32_T const **)

22301
              malloc(1 * sizeof(real32_T *));

22302
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22303
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;

22304
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

22305
            _ssSetInputPortNumDimensions(childS, 2, 1);

22306
            ssSetInputPortWidth(childS, 2, 1);

22307
          }

22308
        }

22309


22310
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

22311
          RegNumOutputPorts);

22312
        ssSetRegNumOutputPortsFcnArg(childS,childS);

22313


22314
        /* outputs */

22315
        {

22316
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

22317
            calloc(1, sizeof(struct _ssPortOutputs));

22318
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

22319
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

22320
          _ssSetNumOutputPorts(childS, 1);

22321


22322
          /* port 0 */

22323
          {

22324
            _ssSetOutputPortNumDimensions(childS, 0, 1);

22325
            ssSetOutputPortWidth(childS, 0, 1);

22326
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

22327
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_n1));

22328
          }

22329
        }

22330


22331
        /* path info */

22332
        _ssSetModelName(childS, "SaturationLimiter_sf");

22333
        _ssSetPath(childS,

22334
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter3/Generated S-Function1");

22335
        if (ssGetRTModel(rts) == (NULL)) {

22336
          _ssSetParentSS(childS, rts);

22337
          _ssSetRootSS(childS, ssGetRootSS(rts));

22338
        } else {

22339
          ssSetRTModel(childS,ssGetRTModel(rts));

22340
          _ssSetParentSS(childS, (NULL));

22341
          _ssSetRootSS(childS, childS);

22342
        }

22343


22344
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

22345
        (childS)->regDataType.arg1 = ((void *)(childS));

22346
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

22347
          FcnSetErrorStatus);

22348
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

22349
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

22350
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

22351
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

22352


22353
        /* registration */

22354
#if defined(MATLAB_MEX_FILE)

22355


22356
        {

22357
          int_T i;

22358
          mxArray *plhs[1];

22359
          mxArray *prhs[4];

22360
          double *pr;

22361
          volatile int_T *intS = (int_T *)&childS;

22362
          int_T addrlen = sizeof(SimStruct *);

22363
          int_T m = addrlen/sizeof(int_T) + 1;

22364
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

22365
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

22366
          pr = mxGetPr(prhs[1]);

22367
          for (i = 0; i < m - 1; i++) {

22368
            pr[i] = (double)intS[i];

22369
          }

22370


22371
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

22372
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

22373
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

22374


22375
          /* Reset port dimensions info functions because the S-function

22376
           * and accelerator mex-files explicitly set their dimensions,

22377
           * i.e., they are not dynamically sized. For this case, the

22378
           * mex-file is responsible for the dimensions info memory

22379
           * and Simulink should not free it. This is achieved by

22380
           * setting the following two methods to NULL.

22381
           */

22382
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

22383
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

22384


22385
          /*

22386
           * Setup function pointers and call mdlInitializeSizes via

22387
           * simulink.c

22388
           */

22389
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

22390
          mxDestroyArray(plhs[0]);

22391
          mxDestroyArray(prhs[0]);

22392
          mxDestroyArray(prhs[1]);

22393
          mxDestroyArray(prhs[2]);

22394
          mxDestroyArray(prhs[3]);

22395
        }

22396


22397
#else

22398


22399
        {

22400
          SaturationLimiter_sf(childS);

22401
          sfcnInitializeSizes(childS);

22402
        }

22403


22404
#endif

22405


22406
        sfcnInitializeSampleTimes(childS);

22407


22408
        /* adjust sample time */

22409
        ssSetSampleTime(childS, 0, 0.0);

22410
        ssSetOffsetTime(childS, 0, 0.0);

22411
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

22412


22413
        /* set compiled values of dynamic vector attributes */

22414
        ssSetNumNonsampledZCs(childS, 0);

22415


22416
        /* Update connectivity flags for each port */

22417
        _ssSetInputPortConnected(childS, 0, 1);

22418
        _ssSetInputPortConnected(childS, 1, 1);

22419
        _ssSetInputPortConnected(childS, 2, 1);

22420
        _ssSetOutputPortConnected(childS, 0, 1);

22421
        _ssSetOutputPortBeingMerged(childS, 0, 0);

22422


22423
        /* Update the BufferDstPort flags for each input port */

22424
        _ssSetInputPortBufferDstPort(childS, 0, -1);

22425
        _ssSetInputPortBufferDstPort(childS, 1, -1);

22426
        _ssSetInputPortBufferDstPort(childS, 2, -1);

22427
      }

22428


22429
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S168>/Generated S-Function (Gain_sf) */

22430
      {

22431
        SimStruct *childS = ssGetSFunction(rts, 84);

22432


22433
        /* timing info */

22434
        time_T *sfcnPeriod;

22435
        time_T *sfcnOffset;

22436
        int_T *sfcnTsMap;

22437
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

22438
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

22439
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

22440
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

22441
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

22442
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

22443
        (void) memset((void*)sfcnPeriod, 0,

22444
                      sizeof(time_T)*1);

22445
        (void) memset((void*)sfcnOffset, 0,

22446
                      sizeof(time_T)*1);

22447
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

22448
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

22449
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

22450


22451
        /* Set up the mdlInfo pointer */

22452
# ifdef USE_RTMODEL

22453


22454
        {

22455
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

22456
              struct _ssBlkInfo2));

22457
          ss_VALIDATE_MEMORY(rts,blkInfo2);

22458
          ssSetBlkInfo2Ptr(childS, blkInfo2);

22459
        }

22460


22461
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

22462


22463
# else

22464


22465
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

22466


22467
# endif                                /* USE_RTMODEL */

22468


22469
        /* Allocate memory of model methods 2 */

22470
        {

22471
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

22472
            malloc(sizeof(struct _ssSFcnModelMethods2));

22473
          ss_VALIDATE_MEMORY(rts,methods2);

22474
          ssSetModelMethods2(childS, methods2);

22475
        }

22476


22477
        /* Allocate memory of model methods 3 */

22478
        {

22479
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

22480
            malloc(sizeof(struct _ssSFcnModelMethods3));

22481
          ss_VALIDATE_MEMORY(rts,methods3);

22482
          ssSetModelMethods3(childS, methods3);

22483
        }

22484


22485
        /* Allocate memory for states auxilliary information */

22486
        {

22487
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

22488
            (sizeof(struct _ssStatesInfo2));

22489
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

22490
            malloc(sizeof(ssPeriodicStatesInfo));

22491
          ss_VALIDATE_MEMORY(rts,statesInfo2);

22492
          ssSetStatesInfo2(childS, statesInfo2);

22493
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

22494
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

22495
        }

22496


22497
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

22498
          RegNumInputPorts);

22499
        ssSetRegNumInputPortsFcnArg(childS,childS);

22500


22501
        /* inputs */

22502
        {

22503
          struct _ssPortInputs *inputPortInfo =

22504
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

22505
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

22506
          _ssSetNumInputPorts(childS, 2);

22507
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

22508


22509
          /* port 0 */

22510
          {

22511
            real32_T const **sfcnUPtrs = (real32_T const **)

22512
              malloc(1 * sizeof(real32_T *));

22513
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22514
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

22515
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_n1;

22516
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

22517
            _ssSetInputPortNumDimensions(childS, 0, 1);

22518
            ssSetInputPortWidth(childS, 0, 1);

22519
          }

22520


22521
          /* port 1 */

22522
          {

22523
            real32_T const **sfcnUPtrs = (real32_T const **)

22524
              malloc(1 * sizeof(real32_T *));

22525
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22526
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;

22527
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

22528
            _ssSetInputPortNumDimensions(childS, 1, 1);

22529
            ssSetInputPortWidth(childS, 1, 1);

22530
          }

22531
        }

22532


22533
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

22534
          RegNumOutputPorts);

22535
        ssSetRegNumOutputPortsFcnArg(childS,childS);

22536


22537
        /* outputs */

22538
        {

22539
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

22540
            calloc(1, sizeof(struct _ssPortOutputs));

22541
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

22542
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

22543
          _ssSetNumOutputPorts(childS, 1);

22544


22545
          /* port 0 */

22546
          {

22547
            _ssSetOutputPortNumDimensions(childS, 0, 1);

22548
            ssSetOutputPortWidth(childS, 0, 1);

22549
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

22550
              ssGetLocalBlockIO(rts))->GeneratedSFunction_fb));

22551
          }

22552
        }

22553


22554
        /* path info */

22555
        _ssSetModelName(childS, "Gain_sf");

22556
        _ssSetPath(childS,

22557
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain3/Generated S-Function");

22558
        if (ssGetRTModel(rts) == (NULL)) {

22559
          _ssSetParentSS(childS, rts);

22560
          _ssSetRootSS(childS, ssGetRootSS(rts));

22561
        } else {

22562
          ssSetRTModel(childS,ssGetRTModel(rts));

22563
          _ssSetParentSS(childS, (NULL));

22564
          _ssSetRootSS(childS, childS);

22565
        }

22566


22567
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

22568
        (childS)->regDataType.arg1 = ((void *)(childS));

22569
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

22570
          FcnSetErrorStatus);

22571
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

22572
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

22573
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

22574
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

22575


22576
        /* registration */

22577
#if defined(MATLAB_MEX_FILE)

22578


22579
        {

22580
          int_T i;

22581
          mxArray *plhs[1];

22582
          mxArray *prhs[4];

22583
          double *pr;

22584
          volatile int_T *intS = (int_T *)&childS;

22585
          int_T addrlen = sizeof(SimStruct *);

22586
          int_T m = addrlen/sizeof(int_T) + 1;

22587
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

22588
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

22589
          pr = mxGetPr(prhs[1]);

22590
          for (i = 0; i < m - 1; i++) {

22591
            pr[i] = (double)intS[i];

22592
          }

22593


22594
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

22595
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

22596
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

22597


22598
          /* Reset port dimensions info functions because the S-function

22599
           * and accelerator mex-files explicitly set their dimensions,

22600
           * i.e., they are not dynamically sized. For this case, the

22601
           * mex-file is responsible for the dimensions info memory

22602
           * and Simulink should not free it. This is achieved by

22603
           * setting the following two methods to NULL.

22604
           */

22605
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

22606
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

22607


22608
          /*

22609
           * Setup function pointers and call mdlInitializeSizes via

22610
           * simulink.c

22611
           */

22612
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

22613
          mxDestroyArray(plhs[0]);

22614
          mxDestroyArray(prhs[0]);

22615
          mxDestroyArray(prhs[1]);

22616
          mxDestroyArray(prhs[2]);

22617
          mxDestroyArray(prhs[3]);

22618
        }

22619


22620
#else

22621


22622
        {

22623
          Gain_sf(childS);

22624
          sfcnInitializeSizes(childS);

22625
        }

22626


22627
#endif

22628


22629
        sfcnInitializeSampleTimes(childS);

22630


22631
        /* adjust sample time */

22632
        ssSetSampleTime(childS, 0, 0.0);

22633
        ssSetOffsetTime(childS, 0, 0.0);

22634
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

22635


22636
        /* set compiled values of dynamic vector attributes */

22637
        ssSetNumNonsampledZCs(childS, 0);

22638


22639
        /* Update connectivity flags for each port */

22640
        _ssSetInputPortConnected(childS, 0, 1);

22641
        _ssSetInputPortConnected(childS, 1, 1);

22642
        _ssSetOutputPortConnected(childS, 0, 1);

22643
        _ssSetOutputPortBeingMerged(childS, 0, 0);

22644


22645
        /* Update the BufferDstPort flags for each input port */

22646
        _ssSetInputPortBufferDstPort(childS, 0, -1);

22647
        _ssSetInputPortBufferDstPort(childS, 1, -1);

22648
      }

22649


22650
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S169>/Generated S-Function (Gain_sf) */

22651
      {

22652
        SimStruct *childS = ssGetSFunction(rts, 85);

22653


22654
        /* timing info */

22655
        time_T *sfcnPeriod;

22656
        time_T *sfcnOffset;

22657
        int_T *sfcnTsMap;

22658
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

22659
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

22660
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

22661
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

22662
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

22663
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

22664
        (void) memset((void*)sfcnPeriod, 0,

22665
                      sizeof(time_T)*1);

22666
        (void) memset((void*)sfcnOffset, 0,

22667
                      sizeof(time_T)*1);

22668
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

22669
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

22670
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

22671


22672
        /* Set up the mdlInfo pointer */

22673
# ifdef USE_RTMODEL

22674


22675
        {

22676
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

22677
              struct _ssBlkInfo2));

22678
          ss_VALIDATE_MEMORY(rts,blkInfo2);

22679
          ssSetBlkInfo2Ptr(childS, blkInfo2);

22680
        }

22681


22682
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

22683


22684
# else

22685


22686
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

22687


22688
# endif                                /* USE_RTMODEL */

22689


22690
        /* Allocate memory of model methods 2 */

22691
        {

22692
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

22693
            malloc(sizeof(struct _ssSFcnModelMethods2));

22694
          ss_VALIDATE_MEMORY(rts,methods2);

22695
          ssSetModelMethods2(childS, methods2);

22696
        }

22697


22698
        /* Allocate memory of model methods 3 */

22699
        {

22700
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

22701
            malloc(sizeof(struct _ssSFcnModelMethods3));

22702
          ss_VALIDATE_MEMORY(rts,methods3);

22703
          ssSetModelMethods3(childS, methods3);

22704
        }

22705


22706
        /* Allocate memory for states auxilliary information */

22707
        {

22708
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

22709
            (sizeof(struct _ssStatesInfo2));

22710
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

22711
            malloc(sizeof(ssPeriodicStatesInfo));

22712
          ss_VALIDATE_MEMORY(rts,statesInfo2);

22713
          ssSetStatesInfo2(childS, statesInfo2);

22714
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

22715
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

22716
        }

22717


22718
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

22719
          RegNumInputPorts);

22720
        ssSetRegNumInputPortsFcnArg(childS,childS);

22721


22722
        /* inputs */

22723
        {

22724
          struct _ssPortInputs *inputPortInfo =

22725
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

22726
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

22727
          _ssSetNumInputPorts(childS, 2);

22728
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

22729


22730
          /* port 0 */

22731
          {

22732
            real32_T const **sfcnUPtrs = (real32_T const **)

22733
              malloc(1 * sizeof(real32_T *));

22734
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22735
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

22736
              ssGetLocalBlockIO(rts))->GeneratedSFunction_fb;

22737
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

22738
            _ssSetInputPortNumDimensions(childS, 0, 1);

22739
            ssSetInputPortWidth(childS, 0, 1);

22740
          }

22741


22742
          /* port 1 */

22743
          {

22744
            real32_T const **sfcnUPtrs = (real32_T const **)

22745
              malloc(1 * sizeof(real32_T *));

22746
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22747
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

22748
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

22749
            _ssSetInputPortNumDimensions(childS, 1, 1);

22750
            ssSetInputPortWidth(childS, 1, 1);

22751
          }

22752
        }

22753


22754
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

22755
          RegNumOutputPorts);

22756
        ssSetRegNumOutputPortsFcnArg(childS,childS);

22757


22758
        /* outputs */

22759
        {

22760
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

22761
            calloc(1, sizeof(struct _ssPortOutputs));

22762
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

22763
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

22764
          _ssSetNumOutputPorts(childS, 1);

22765


22766
          /* port 0 */

22767
          {

22768
            _ssSetOutputPortNumDimensions(childS, 0, 1);

22769
            ssSetOutputPortWidth(childS, 0, 1);

22770
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

22771
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ok));

22772
          }

22773
        }

22774


22775
        /* path info */

22776
        _ssSetModelName(childS, "Gain_sf");

22777
        _ssSetPath(childS,

22778
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain4/Generated S-Function");

22779
        if (ssGetRTModel(rts) == (NULL)) {

22780
          _ssSetParentSS(childS, rts);

22781
          _ssSetRootSS(childS, ssGetRootSS(rts));

22782
        } else {

22783
          ssSetRTModel(childS,ssGetRTModel(rts));

22784
          _ssSetParentSS(childS, (NULL));

22785
          _ssSetRootSS(childS, childS);

22786
        }

22787


22788
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

22789
        (childS)->regDataType.arg1 = ((void *)(childS));

22790
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

22791
          FcnSetErrorStatus);

22792
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

22793
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

22794
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

22795
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

22796


22797
        /* registration */

22798
#if defined(MATLAB_MEX_FILE)

22799


22800
        {

22801
          int_T i;

22802
          mxArray *plhs[1];

22803
          mxArray *prhs[4];

22804
          double *pr;

22805
          volatile int_T *intS = (int_T *)&childS;

22806
          int_T addrlen = sizeof(SimStruct *);

22807
          int_T m = addrlen/sizeof(int_T) + 1;

22808
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

22809
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

22810
          pr = mxGetPr(prhs[1]);

22811
          for (i = 0; i < m - 1; i++) {

22812
            pr[i] = (double)intS[i];

22813
          }

22814


22815
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

22816
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

22817
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

22818


22819
          /* Reset port dimensions info functions because the S-function

22820
           * and accelerator mex-files explicitly set their dimensions,

22821
           * i.e., they are not dynamically sized. For this case, the

22822
           * mex-file is responsible for the dimensions info memory

22823
           * and Simulink should not free it. This is achieved by

22824
           * setting the following two methods to NULL.

22825
           */

22826
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

22827
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

22828


22829
          /*

22830
           * Setup function pointers and call mdlInitializeSizes via

22831
           * simulink.c

22832
           */

22833
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

22834
          mxDestroyArray(plhs[0]);

22835
          mxDestroyArray(prhs[0]);

22836
          mxDestroyArray(prhs[1]);

22837
          mxDestroyArray(prhs[2]);

22838
          mxDestroyArray(prhs[3]);

22839
        }

22840


22841
#else

22842


22843
        {

22844
          Gain_sf(childS);

22845
          sfcnInitializeSizes(childS);

22846
        }

22847


22848
#endif

22849


22850
        sfcnInitializeSampleTimes(childS);

22851


22852
        /* adjust sample time */

22853
        ssSetSampleTime(childS, 0, 0.0);

22854
        ssSetOffsetTime(childS, 0, 0.0);

22855
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

22856


22857
        /* set compiled values of dynamic vector attributes */

22858
        ssSetNumNonsampledZCs(childS, 0);

22859


22860
        /* Update connectivity flags for each port */

22861
        _ssSetInputPortConnected(childS, 0, 1);

22862
        _ssSetInputPortConnected(childS, 1, 1);

22863
        _ssSetOutputPortConnected(childS, 0, 1);

22864
        _ssSetOutputPortBeingMerged(childS, 0, 0);

22865


22866
        /* Update the BufferDstPort flags for each input port */

22867
        _ssSetInputPortBufferDstPort(childS, 0, -1);

22868
        _ssSetInputPortBufferDstPort(childS, 1, -1);

22869
      }

22870


22871
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S160>/Generated S-Function3 (IntegratorLimited_sf) */

22872
      {

22873
        SimStruct *childS = ssGetSFunction(rts, 86);

22874


22875
        /* timing info */

22876
        time_T *sfcnPeriod;

22877
        time_T *sfcnOffset;

22878
        int_T *sfcnTsMap;

22879
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

22880
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

22881
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

22882
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

22883
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

22884
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

22885
        (void) memset((void*)sfcnPeriod, 0,

22886
                      sizeof(time_T)*1);

22887
        (void) memset((void*)sfcnOffset, 0,

22888
                      sizeof(time_T)*1);

22889
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

22890
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

22891
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

22892


22893
        /* Set up the mdlInfo pointer */

22894
# ifdef USE_RTMODEL

22895


22896
        {

22897
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

22898
              struct _ssBlkInfo2));

22899
          ss_VALIDATE_MEMORY(rts,blkInfo2);

22900
          ssSetBlkInfo2Ptr(childS, blkInfo2);

22901
        }

22902


22903
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

22904


22905
# else

22906


22907
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

22908


22909
# endif                                /* USE_RTMODEL */

22910


22911
        /* Allocate memory of model methods 2 */

22912
        {

22913
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

22914
            malloc(sizeof(struct _ssSFcnModelMethods2));

22915
          ss_VALIDATE_MEMORY(rts,methods2);

22916
          ssSetModelMethods2(childS, methods2);

22917
        }

22918


22919
        /* Allocate memory of model methods 3 */

22920
        {

22921
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

22922
            malloc(sizeof(struct _ssSFcnModelMethods3));

22923
          ss_VALIDATE_MEMORY(rts,methods3);

22924
          ssSetModelMethods3(childS, methods3);

22925
        }

22926


22927
        /* Allocate memory for states auxilliary information */

22928
        {

22929
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

22930
            (sizeof(struct _ssStatesInfo2));

22931
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

22932
            malloc(sizeof(ssPeriodicStatesInfo));

22933
          ss_VALIDATE_MEMORY(rts,statesInfo2);

22934
          ssSetStatesInfo2(childS, statesInfo2);

22935
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

22936
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

22937
        }

22938


22939
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

22940
          RegNumInputPorts);

22941
        ssSetRegNumInputPortsFcnArg(childS,childS);

22942


22943
        /* inputs */

22944
        {

22945
          struct _ssPortInputs *inputPortInfo =

22946
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

22947
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

22948
          _ssSetNumInputPorts(childS, 7);

22949
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

22950


22951
          /* port 0 */

22952
          {

22953
            real32_T const **sfcnUPtrs = (real32_T const **)

22954
              malloc(1 * sizeof(real32_T *));

22955
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22956
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

22957
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

22958
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

22959
            _ssSetInputPortNumDimensions(childS, 0, 1);

22960
            ssSetInputPortWidth(childS, 0, 1);

22961
          }

22962


22963
          /* port 1 */

22964
          {

22965
            int8_T const **sfcnUPtrs = (int8_T const **)

22966
              malloc(1 * sizeof(int8_T *));

22967
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22968
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

22969
              ssGetLocalBlockIO(rts))->DataTypeConversion4_g;

22970
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

22971
            _ssSetInputPortNumDimensions(childS, 1, 1);

22972
            ssSetInputPortWidth(childS, 1, 1);

22973
          }

22974


22975
          /* port 2 */

22976
          {

22977
            real32_T const **sfcnUPtrs = (real32_T const **)

22978
              malloc(1 * sizeof(real32_T *));

22979
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22980
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

22981
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

22982
            _ssSetInputPortNumDimensions(childS, 2, 1);

22983
            ssSetInputPortWidth(childS, 2, 1);

22984
          }

22985


22986
          /* port 3 */

22987
          {

22988
            real32_T const **sfcnUPtrs = (real32_T const **)

22989
              malloc(1 * sizeof(real32_T *));

22990
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

22991
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

22992
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

22993
            _ssSetInputPortNumDimensions(childS, 3, 1);

22994
            ssSetInputPortWidth(childS, 3, 1);

22995
          }

22996


22997
          /* port 4 */

22998
          {

22999
            real32_T const **sfcnUPtrs = (real32_T const **)

23000
              malloc(1 * sizeof(real32_T *));

23001
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23002
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;

23003
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

23004
            _ssSetInputPortNumDimensions(childS, 4, 1);

23005
            ssSetInputPortWidth(childS, 4, 1);

23006
          }

23007


23008
          /* port 5 */

23009
          {

23010
            real32_T const **sfcnUPtrs = (real32_T const **)

23011
              malloc(1 * sizeof(real32_T *));

23012
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23013
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;

23014
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

23015
            _ssSetInputPortNumDimensions(childS, 5, 1);

23016
            ssSetInputPortWidth(childS, 5, 1);

23017
          }

23018


23019
          /* port 6 */

23020
          {

23021
            real32_T const **sfcnUPtrs = (real32_T const **)

23022
              malloc(1 * sizeof(real32_T *));

23023
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23024
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

23025
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ok;

23026
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

23027
            _ssSetInputPortNumDimensions(childS, 6, 1);

23028
            ssSetInputPortWidth(childS, 6, 1);

23029
          }

23030
        }

23031


23032
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

23033
          RegNumOutputPorts);

23034
        ssSetRegNumOutputPortsFcnArg(childS,childS);

23035


23036
        /* outputs */

23037
        {

23038
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

23039
            calloc(1, sizeof(struct _ssPortOutputs));

23040
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

23041
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

23042
          _ssSetNumOutputPorts(childS, 1);

23043


23044
          /* port 0 */

23045
          {

23046
            _ssSetOutputPortNumDimensions(childS, 0, 1);

23047
            ssSetOutputPortWidth(childS, 0, 1);

23048
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

23049
              ssGetLocalBlockIO(rts))->Saturation2_p));

23050
          }

23051
        }

23052


23053
        /* path info */

23054
        _ssSetModelName(childS, "IntegratorLimited_sf");

23055
        _ssSetPath(childS,

23056
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Integrator Limited1/Generated S-Function3");

23057
        if (ssGetRTModel(rts) == (NULL)) {

23058
          _ssSetParentSS(childS, rts);

23059
          _ssSetRootSS(childS, ssGetRootSS(rts));

23060
        } else {

23061
          ssSetRTModel(childS,ssGetRTModel(rts));

23062
          _ssSetParentSS(childS, (NULL));

23063
          _ssSetRootSS(childS, childS);

23064
        }

23065


23066
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

23067


23068
        /* work vectors */

23069
        {

23070
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

23071
            (4 * sizeof(struct _ssDWorkRecord));

23072
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

23073
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

23074
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

23075
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

23076
          ssSetSFcnDWork(childS, dWorkRecord);

23077
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

23078
          _ssSetNumDWork(childS, 4);

23079


23080
          /* DWORK0 */

23081
          ssSetDWorkWidth(childS, 0, 1);

23082
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

23083
          ssSetDWorkComplexSignal(childS, 0, 0);

23084
          ssSetDWorkUsedAsDState(childS, 0, 1);

23085
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 214))[0]);

23086


23087
          /* DWORK1 */

23088
          ssSetDWorkWidth(childS, 1, 1);

23089
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

23090
          ssSetDWorkComplexSignal(childS, 1, 0);

23091
          ssSetDWorkUsedAsDState(childS, 1, 1);

23092
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 215))[0]);

23093


23094
          /* DWORK2 */

23095
          ssSetDWorkWidth(childS, 2, 1);

23096
          ssSetDWorkDataType(childS, 2,SS_INT8);

23097
          ssSetDWorkComplexSignal(childS, 2, 0);

23098
          ssSetDWorkUsedAsDState(childS, 2, 1);

23099
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 441))[0]);

23100


23101
          /* DWORK3 */

23102
          ssSetDWorkWidth(childS, 3, 1);

23103
          ssSetDWorkDataType(childS, 3,SS_INT8);

23104
          ssSetDWorkComplexSignal(childS, 3, 0);

23105
          ssSetDWorkUsedAsDState(childS, 3, 1);

23106
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 442))[0]);

23107
        }

23108


23109
        (childS)->regDataType.arg1 = ((void *)(childS));

23110
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

23111
          FcnSetErrorStatus);

23112
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

23113
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

23114
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

23115
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

23116


23117
        /* registration */

23118
#if defined(MATLAB_MEX_FILE)

23119


23120
        {

23121
          int_T i;

23122
          mxArray *plhs[1];

23123
          mxArray *prhs[4];

23124
          double *pr;

23125
          volatile int_T *intS = (int_T *)&childS;

23126
          int_T addrlen = sizeof(SimStruct *);

23127
          int_T m = addrlen/sizeof(int_T) + 1;

23128
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

23129
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

23130
          pr = mxGetPr(prhs[1]);

23131
          for (i = 0; i < m - 1; i++) {

23132
            pr[i] = (double)intS[i];

23133
          }

23134


23135
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

23136
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

23137
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

23138


23139
          /* Reset port dimensions info functions because the S-function

23140
           * and accelerator mex-files explicitly set their dimensions,

23141
           * i.e., they are not dynamically sized. For this case, the

23142
           * mex-file is responsible for the dimensions info memory

23143
           * and Simulink should not free it. This is achieved by

23144
           * setting the following two methods to NULL.

23145
           */

23146
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

23147
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

23148


23149
          /*

23150
           * Setup function pointers and call mdlInitializeSizes via

23151
           * simulink.c

23152
           */

23153
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

23154
          mxDestroyArray(plhs[0]);

23155
          mxDestroyArray(prhs[0]);

23156
          mxDestroyArray(prhs[1]);

23157
          mxDestroyArray(prhs[2]);

23158
          mxDestroyArray(prhs[3]);

23159
        }

23160


23161
#else

23162


23163
        {

23164
          IntegratorLimited_sf(childS);

23165
          sfcnInitializeSizes(childS);

23166
        }

23167


23168
#endif

23169


23170
        sfcnInitializeSampleTimes(childS);

23171


23172
        /* adjust sample time */

23173
        ssSetSampleTime(childS, 0, 0.0);

23174
        ssSetOffsetTime(childS, 0, 0.0);

23175
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

23176


23177
        /* set compiled values of dynamic vector attributes */

23178
        ssSetNumNonsampledZCs(childS, 0);

23179


23180
        /* Update connectivity flags for each port */

23181
        _ssSetInputPortConnected(childS, 0, 1);

23182
        _ssSetInputPortConnected(childS, 1, 1);

23183
        _ssSetInputPortConnected(childS, 2, 1);

23184
        _ssSetInputPortConnected(childS, 3, 1);

23185
        _ssSetInputPortConnected(childS, 4, 1);

23186
        _ssSetInputPortConnected(childS, 5, 1);

23187
        _ssSetInputPortConnected(childS, 6, 1);

23188
        _ssSetOutputPortConnected(childS, 0, 1);

23189
        _ssSetOutputPortBeingMerged(childS, 0, 0);

23190


23191
        /* Update the BufferDstPort flags for each input port */

23192
        _ssSetInputPortBufferDstPort(childS, 0, -1);

23193
        _ssSetInputPortBufferDstPort(childS, 1, -1);

23194
        _ssSetInputPortBufferDstPort(childS, 2, -1);

23195
        _ssSetInputPortBufferDstPort(childS, 3, -1);

23196
        _ssSetInputPortBufferDstPort(childS, 4, -1);

23197
        _ssSetInputPortBufferDstPort(childS, 5, -1);

23198
        _ssSetInputPortBufferDstPort(childS, 6, -1);

23199
      }

23200


23201
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S129>/Generated S-Function6 (Res180_sf) */

23202
      {

23203
        SimStruct *childS = ssGetSFunction(rts, 87);

23204


23205
        /* timing info */

23206
        time_T *sfcnPeriod;

23207
        time_T *sfcnOffset;

23208
        int_T *sfcnTsMap;

23209
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

23210
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

23211
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

23212
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

23213
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

23214
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

23215
        (void) memset((void*)sfcnPeriod, 0,

23216
                      sizeof(time_T)*1);

23217
        (void) memset((void*)sfcnOffset, 0,

23218
                      sizeof(time_T)*1);

23219
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

23220
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

23221
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

23222


23223
        /* Set up the mdlInfo pointer */

23224
# ifdef USE_RTMODEL

23225


23226
        {

23227
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

23228
              struct _ssBlkInfo2));

23229
          ss_VALIDATE_MEMORY(rts,blkInfo2);

23230
          ssSetBlkInfo2Ptr(childS, blkInfo2);

23231
        }

23232


23233
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

23234


23235
# else

23236


23237
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

23238


23239
# endif                                /* USE_RTMODEL */

23240


23241
        /* Allocate memory of model methods 2 */

23242
        {

23243
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

23244
            malloc(sizeof(struct _ssSFcnModelMethods2));

23245
          ss_VALIDATE_MEMORY(rts,methods2);

23246
          ssSetModelMethods2(childS, methods2);

23247
        }

23248


23249
        /* Allocate memory of model methods 3 */

23250
        {

23251
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

23252
            malloc(sizeof(struct _ssSFcnModelMethods3));

23253
          ss_VALIDATE_MEMORY(rts,methods3);

23254
          ssSetModelMethods3(childS, methods3);

23255
        }

23256


23257
        /* Allocate memory for states auxilliary information */

23258
        {

23259
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

23260
            (sizeof(struct _ssStatesInfo2));

23261
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

23262
            malloc(sizeof(ssPeriodicStatesInfo));

23263
          ss_VALIDATE_MEMORY(rts,statesInfo2);

23264
          ssSetStatesInfo2(childS, statesInfo2);

23265
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

23266
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

23267
        }

23268


23269
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

23270
          RegNumInputPorts);

23271
        ssSetRegNumInputPortsFcnArg(childS,childS);

23272


23273
        /* inputs */

23274
        {

23275
          struct _ssPortInputs *inputPortInfo =

23276
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

23277
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

23278
          _ssSetNumInputPorts(childS, 1);

23279
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

23280


23281
          /* port 0 */

23282
          {

23283
            real32_T const **sfcnUPtrs = (real32_T const **)

23284
              malloc(1 * sizeof(real32_T *));

23285
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23286
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

23287
              ssGetLocalBlockIO(rts))->Sum3_cy;

23288
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

23289
            _ssSetInputPortNumDimensions(childS, 0, 1);

23290
            ssSetInputPortWidth(childS, 0, 1);

23291
          }

23292
        }

23293


23294
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

23295
          RegNumOutputPorts);

23296
        ssSetRegNumOutputPortsFcnArg(childS,childS);

23297


23298
        /* outputs */

23299
        {

23300
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

23301
            calloc(1, sizeof(struct _ssPortOutputs));

23302
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

23303
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

23304
          _ssSetNumOutputPorts(childS, 1);

23305


23306
          /* port 0 */

23307
          {

23308
            _ssSetOutputPortNumDimensions(childS, 0, 1);

23309
            ssSetOutputPortWidth(childS, 0, 1);

23310
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

23311
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_h3));

23312
          }

23313
        }

23314


23315
        /* path info */

23316
        _ssSetModelName(childS, "Res180_sf");

23317
        _ssSetPath(childS,

23318
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Generated S-Function6");

23319
        if (ssGetRTModel(rts) == (NULL)) {

23320
          _ssSetParentSS(childS, rts);

23321
          _ssSetRootSS(childS, ssGetRootSS(rts));

23322
        } else {

23323
          ssSetRTModel(childS,ssGetRTModel(rts));

23324
          _ssSetParentSS(childS, (NULL));

23325
          _ssSetRootSS(childS, childS);

23326
        }

23327


23328
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

23329
        (childS)->regDataType.arg1 = ((void *)(childS));

23330
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

23331
          FcnSetErrorStatus);

23332
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

23333
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

23334
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

23335
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

23336


23337
        /* registration */

23338
#if defined(MATLAB_MEX_FILE)

23339


23340
        {

23341
          int_T i;

23342
          mxArray *plhs[1];

23343
          mxArray *prhs[4];

23344
          double *pr;

23345
          volatile int_T *intS = (int_T *)&childS;

23346
          int_T addrlen = sizeof(SimStruct *);

23347
          int_T m = addrlen/sizeof(int_T) + 1;

23348
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

23349
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

23350
          pr = mxGetPr(prhs[1]);

23351
          for (i = 0; i < m - 1; i++) {

23352
            pr[i] = (double)intS[i];

23353
          }

23354


23355
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

23356
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

23357
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

23358


23359
          /* Reset port dimensions info functions because the S-function

23360
           * and accelerator mex-files explicitly set their dimensions,

23361
           * i.e., they are not dynamically sized. For this case, the

23362
           * mex-file is responsible for the dimensions info memory

23363
           * and Simulink should not free it. This is achieved by

23364
           * setting the following two methods to NULL.

23365
           */

23366
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

23367
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

23368


23369
          /*

23370
           * Setup function pointers and call mdlInitializeSizes via

23371
           * simulink.c

23372
           */

23373
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

23374
          mxDestroyArray(plhs[0]);

23375
          mxDestroyArray(prhs[0]);

23376
          mxDestroyArray(prhs[1]);

23377
          mxDestroyArray(prhs[2]);

23378
          mxDestroyArray(prhs[3]);

23379
        }

23380


23381
#else

23382


23383
        {

23384
          Res180_sf(childS);

23385
          sfcnInitializeSizes(childS);

23386
        }

23387


23388
#endif

23389


23390
        sfcnInitializeSampleTimes(childS);

23391


23392
        /* adjust sample time */

23393
        ssSetSampleTime(childS, 0, 0.0);

23394
        ssSetOffsetTime(childS, 0, 0.0);

23395
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

23396


23397
        /* set compiled values of dynamic vector attributes */

23398
        ssSetNumNonsampledZCs(childS, 0);

23399


23400
        /* Update connectivity flags for each port */

23401
        _ssSetInputPortConnected(childS, 0, 1);

23402
        _ssSetOutputPortConnected(childS, 0, 1);

23403
        _ssSetOutputPortBeingMerged(childS, 0, 0);

23404


23405
        /* Update the BufferDstPort flags for each input port */

23406
        _ssSetInputPortBufferDstPort(childS, 0, -1);

23407
      }

23408


23409
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S162>/Generated S-Function1 (SaturationLimiter_sf) */

23410
      {

23411
        SimStruct *childS = ssGetSFunction(rts, 88);

23412


23413
        /* timing info */

23414
        time_T *sfcnPeriod;

23415
        time_T *sfcnOffset;

23416
        int_T *sfcnTsMap;

23417
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

23418
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

23419
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

23420
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

23421
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

23422
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

23423
        (void) memset((void*)sfcnPeriod, 0,

23424
                      sizeof(time_T)*1);

23425
        (void) memset((void*)sfcnOffset, 0,

23426
                      sizeof(time_T)*1);

23427
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

23428
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

23429
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

23430


23431
        /* Set up the mdlInfo pointer */

23432
# ifdef USE_RTMODEL

23433


23434
        {

23435
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

23436
              struct _ssBlkInfo2));

23437
          ss_VALIDATE_MEMORY(rts,blkInfo2);

23438
          ssSetBlkInfo2Ptr(childS, blkInfo2);

23439
        }

23440


23441
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

23442


23443
# else

23444


23445
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

23446


23447
# endif                                /* USE_RTMODEL */

23448


23449
        /* Allocate memory of model methods 2 */

23450
        {

23451
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

23452
            malloc(sizeof(struct _ssSFcnModelMethods2));

23453
          ss_VALIDATE_MEMORY(rts,methods2);

23454
          ssSetModelMethods2(childS, methods2);

23455
        }

23456


23457
        /* Allocate memory of model methods 3 */

23458
        {

23459
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

23460
            malloc(sizeof(struct _ssSFcnModelMethods3));

23461
          ss_VALIDATE_MEMORY(rts,methods3);

23462
          ssSetModelMethods3(childS, methods3);

23463
        }

23464


23465
        /* Allocate memory for states auxilliary information */

23466
        {

23467
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

23468
            (sizeof(struct _ssStatesInfo2));

23469
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

23470
            malloc(sizeof(ssPeriodicStatesInfo));

23471
          ss_VALIDATE_MEMORY(rts,statesInfo2);

23472
          ssSetStatesInfo2(childS, statesInfo2);

23473
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

23474
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

23475
        }

23476


23477
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

23478
          RegNumInputPorts);

23479
        ssSetRegNumInputPortsFcnArg(childS,childS);

23480


23481
        /* inputs */

23482
        {

23483
          struct _ssPortInputs *inputPortInfo =

23484
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

23485
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

23486
          _ssSetNumInputPorts(childS, 3);

23487
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

23488


23489
          /* port 0 */

23490
          {

23491
            real32_T const **sfcnUPtrs = (real32_T const **)

23492
              malloc(1 * sizeof(real32_T *));

23493
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23494
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

23495
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_h3;

23496
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

23497
            _ssSetInputPortNumDimensions(childS, 0, 1);

23498
            ssSetInputPortWidth(childS, 0, 1);

23499
          }

23500


23501
          /* port 1 */

23502
          {

23503
            real32_T const **sfcnUPtrs = (real32_T const **)

23504
              malloc(1 * sizeof(real32_T *));

23505
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23506
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

23507
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

23508
            _ssSetInputPortNumDimensions(childS, 1, 1);

23509
            ssSetInputPortWidth(childS, 1, 1);

23510
          }

23511


23512
          /* port 2 */

23513
          {

23514
            real32_T const **sfcnUPtrs = (real32_T const **)

23515
              malloc(1 * sizeof(real32_T *));

23516
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23517
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;

23518
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

23519
            _ssSetInputPortNumDimensions(childS, 2, 1);

23520
            ssSetInputPortWidth(childS, 2, 1);

23521
          }

23522
        }

23523


23524
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

23525
          RegNumOutputPorts);

23526
        ssSetRegNumOutputPortsFcnArg(childS,childS);

23527


23528
        /* outputs */

23529
        {

23530
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

23531
            calloc(1, sizeof(struct _ssPortOutputs));

23532
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

23533
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

23534
          _ssSetNumOutputPorts(childS, 1);

23535


23536
          /* port 0 */

23537
          {

23538
            _ssSetOutputPortNumDimensions(childS, 0, 1);

23539
            ssSetOutputPortWidth(childS, 0, 1);

23540
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

23541
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_oh));

23542
          }

23543
        }

23544


23545
        /* path info */

23546
        _ssSetModelName(childS, "SaturationLimiter_sf");

23547
        _ssSetPath(childS,

23548
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter1/Generated S-Function1");

23549
        if (ssGetRTModel(rts) == (NULL)) {

23550
          _ssSetParentSS(childS, rts);

23551
          _ssSetRootSS(childS, ssGetRootSS(rts));

23552
        } else {

23553
          ssSetRTModel(childS,ssGetRTModel(rts));

23554
          _ssSetParentSS(childS, (NULL));

23555
          _ssSetRootSS(childS, childS);

23556
        }

23557


23558
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

23559
        (childS)->regDataType.arg1 = ((void *)(childS));

23560
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

23561
          FcnSetErrorStatus);

23562
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

23563
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

23564
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

23565
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

23566


23567
        /* registration */

23568
#if defined(MATLAB_MEX_FILE)

23569


23570
        {

23571
          int_T i;

23572
          mxArray *plhs[1];

23573
          mxArray *prhs[4];

23574
          double *pr;

23575
          volatile int_T *intS = (int_T *)&childS;

23576
          int_T addrlen = sizeof(SimStruct *);

23577
          int_T m = addrlen/sizeof(int_T) + 1;

23578
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

23579
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

23580
          pr = mxGetPr(prhs[1]);

23581
          for (i = 0; i < m - 1; i++) {

23582
            pr[i] = (double)intS[i];

23583
          }

23584


23585
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

23586
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

23587
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

23588


23589
          /* Reset port dimensions info functions because the S-function

23590
           * and accelerator mex-files explicitly set their dimensions,

23591
           * i.e., they are not dynamically sized. For this case, the

23592
           * mex-file is responsible for the dimensions info memory

23593
           * and Simulink should not free it. This is achieved by

23594
           * setting the following two methods to NULL.

23595
           */

23596
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

23597
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

23598


23599
          /*

23600
           * Setup function pointers and call mdlInitializeSizes via

23601
           * simulink.c

23602
           */

23603
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

23604
          mxDestroyArray(plhs[0]);

23605
          mxDestroyArray(prhs[0]);

23606
          mxDestroyArray(prhs[1]);

23607
          mxDestroyArray(prhs[2]);

23608
          mxDestroyArray(prhs[3]);

23609
        }

23610


23611
#else

23612


23613
        {

23614
          SaturationLimiter_sf(childS);

23615
          sfcnInitializeSizes(childS);

23616
        }

23617


23618
#endif

23619


23620
        sfcnInitializeSampleTimes(childS);

23621


23622
        /* adjust sample time */

23623
        ssSetSampleTime(childS, 0, 0.0);

23624
        ssSetOffsetTime(childS, 0, 0.0);

23625
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

23626


23627
        /* set compiled values of dynamic vector attributes */

23628
        ssSetNumNonsampledZCs(childS, 0);

23629


23630
        /* Update connectivity flags for each port */

23631
        _ssSetInputPortConnected(childS, 0, 1);

23632
        _ssSetInputPortConnected(childS, 1, 1);

23633
        _ssSetInputPortConnected(childS, 2, 1);

23634
        _ssSetOutputPortConnected(childS, 0, 1);

23635
        _ssSetOutputPortBeingMerged(childS, 0, 0);

23636


23637
        /* Update the BufferDstPort flags for each input port */

23638
        _ssSetInputPortBufferDstPort(childS, 0, -1);

23639
        _ssSetInputPortBufferDstPort(childS, 1, -1);

23640
        _ssSetInputPortBufferDstPort(childS, 2, -1);

23641
      }

23642


23643
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S167>/Generated S-Function (Gain_sf) */

23644
      {

23645
        SimStruct *childS = ssGetSFunction(rts, 89);

23646


23647
        /* timing info */

23648
        time_T *sfcnPeriod;

23649
        time_T *sfcnOffset;

23650
        int_T *sfcnTsMap;

23651
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

23652
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

23653
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

23654
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

23655
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

23656
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

23657
        (void) memset((void*)sfcnPeriod, 0,

23658
                      sizeof(time_T)*1);

23659
        (void) memset((void*)sfcnOffset, 0,

23660
                      sizeof(time_T)*1);

23661
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

23662
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

23663
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

23664


23665
        /* Set up the mdlInfo pointer */

23666
# ifdef USE_RTMODEL

23667


23668
        {

23669
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

23670
              struct _ssBlkInfo2));

23671
          ss_VALIDATE_MEMORY(rts,blkInfo2);

23672
          ssSetBlkInfo2Ptr(childS, blkInfo2);

23673
        }

23674


23675
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

23676


23677
# else

23678


23679
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

23680


23681
# endif                                /* USE_RTMODEL */

23682


23683
        /* Allocate memory of model methods 2 */

23684
        {

23685
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

23686
            malloc(sizeof(struct _ssSFcnModelMethods2));

23687
          ss_VALIDATE_MEMORY(rts,methods2);

23688
          ssSetModelMethods2(childS, methods2);

23689
        }

23690


23691
        /* Allocate memory of model methods 3 */

23692
        {

23693
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

23694
            malloc(sizeof(struct _ssSFcnModelMethods3));

23695
          ss_VALIDATE_MEMORY(rts,methods3);

23696
          ssSetModelMethods3(childS, methods3);

23697
        }

23698


23699
        /* Allocate memory for states auxilliary information */

23700
        {

23701
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

23702
            (sizeof(struct _ssStatesInfo2));

23703
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

23704
            malloc(sizeof(ssPeriodicStatesInfo));

23705
          ss_VALIDATE_MEMORY(rts,statesInfo2);

23706
          ssSetStatesInfo2(childS, statesInfo2);

23707
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

23708
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

23709
        }

23710


23711
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

23712
          RegNumInputPorts);

23713
        ssSetRegNumInputPortsFcnArg(childS,childS);

23714


23715
        /* inputs */

23716
        {

23717
          struct _ssPortInputs *inputPortInfo =

23718
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

23719
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

23720
          _ssSetNumInputPorts(childS, 2);

23721
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

23722


23723
          /* port 0 */

23724
          {

23725
            real32_T const **sfcnUPtrs = (real32_T const **)

23726
              malloc(1 * sizeof(real32_T *));

23727
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23728
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

23729
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_oh;

23730
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

23731
            _ssSetInputPortNumDimensions(childS, 0, 1);

23732
            ssSetInputPortWidth(childS, 0, 1);

23733
          }

23734


23735
          /* port 1 */

23736
          {

23737
            real32_T const **sfcnUPtrs = (real32_T const **)

23738
              malloc(1 * sizeof(real32_T *));

23739
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23740
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

23741
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

23742
            _ssSetInputPortNumDimensions(childS, 1, 1);

23743
            ssSetInputPortWidth(childS, 1, 1);

23744
          }

23745
        }

23746


23747
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

23748
          RegNumOutputPorts);

23749
        ssSetRegNumOutputPortsFcnArg(childS,childS);

23750


23751
        /* outputs */

23752
        {

23753
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

23754
            calloc(1, sizeof(struct _ssPortOutputs));

23755
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

23756
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

23757
          _ssSetNumOutputPorts(childS, 1);

23758


23759
          /* port 0 */

23760
          {

23761
            _ssSetOutputPortNumDimensions(childS, 0, 1);

23762
            ssSetOutputPortWidth(childS, 0, 1);

23763
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

23764
              ssGetLocalBlockIO(rts))->GeneratedSFunction_mc));

23765
          }

23766
        }

23767


23768
        /* path info */

23769
        _ssSetModelName(childS, "Gain_sf");

23770
        _ssSetPath(childS,

23771
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain2/Generated S-Function");

23772
        if (ssGetRTModel(rts) == (NULL)) {

23773
          _ssSetParentSS(childS, rts);

23774
          _ssSetRootSS(childS, ssGetRootSS(rts));

23775
        } else {

23776
          ssSetRTModel(childS,ssGetRTModel(rts));

23777
          _ssSetParentSS(childS, (NULL));

23778
          _ssSetRootSS(childS, childS);

23779
        }

23780


23781
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

23782
        (childS)->regDataType.arg1 = ((void *)(childS));

23783
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

23784
          FcnSetErrorStatus);

23785
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

23786
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

23787
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

23788
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

23789


23790
        /* registration */

23791
#if defined(MATLAB_MEX_FILE)

23792


23793
        {

23794
          int_T i;

23795
          mxArray *plhs[1];

23796
          mxArray *prhs[4];

23797
          double *pr;

23798
          volatile int_T *intS = (int_T *)&childS;

23799
          int_T addrlen = sizeof(SimStruct *);

23800
          int_T m = addrlen/sizeof(int_T) + 1;

23801
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

23802
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

23803
          pr = mxGetPr(prhs[1]);

23804
          for (i = 0; i < m - 1; i++) {

23805
            pr[i] = (double)intS[i];

23806
          }

23807


23808
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

23809
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

23810
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

23811


23812
          /* Reset port dimensions info functions because the S-function

23813
           * and accelerator mex-files explicitly set their dimensions,

23814
           * i.e., they are not dynamically sized. For this case, the

23815
           * mex-file is responsible for the dimensions info memory

23816
           * and Simulink should not free it. This is achieved by

23817
           * setting the following two methods to NULL.

23818
           */

23819
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

23820
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

23821


23822
          /*

23823
           * Setup function pointers and call mdlInitializeSizes via

23824
           * simulink.c

23825
           */

23826
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

23827
          mxDestroyArray(plhs[0]);

23828
          mxDestroyArray(prhs[0]);

23829
          mxDestroyArray(prhs[1]);

23830
          mxDestroyArray(prhs[2]);

23831
          mxDestroyArray(prhs[3]);

23832
        }

23833


23834
#else

23835


23836
        {

23837
          Gain_sf(childS);

23838
          sfcnInitializeSizes(childS);

23839
        }

23840


23841
#endif

23842


23843
        sfcnInitializeSampleTimes(childS);

23844


23845
        /* adjust sample time */

23846
        ssSetSampleTime(childS, 0, 0.0);

23847
        ssSetOffsetTime(childS, 0, 0.0);

23848
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

23849


23850
        /* set compiled values of dynamic vector attributes */

23851
        ssSetNumNonsampledZCs(childS, 0);

23852


23853
        /* Update connectivity flags for each port */

23854
        _ssSetInputPortConnected(childS, 0, 1);

23855
        _ssSetInputPortConnected(childS, 1, 1);

23856
        _ssSetOutputPortConnected(childS, 0, 1);

23857
        _ssSetOutputPortBeingMerged(childS, 0, 0);

23858


23859
        /* Update the BufferDstPort flags for each input port */

23860
        _ssSetInputPortBufferDstPort(childS, 0, -1);

23861
        _ssSetInputPortBufferDstPort(childS, 1, -1);

23862
      }

23863


23864
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S161>/Generated S-Function1 (SaturationLimiter_sf) */

23865
      {

23866
        SimStruct *childS = ssGetSFunction(rts, 90);

23867


23868
        /* timing info */

23869
        time_T *sfcnPeriod;

23870
        time_T *sfcnOffset;

23871
        int_T *sfcnTsMap;

23872
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

23873
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

23874
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

23875
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

23876
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

23877
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

23878
        (void) memset((void*)sfcnPeriod, 0,

23879
                      sizeof(time_T)*1);

23880
        (void) memset((void*)sfcnOffset, 0,

23881
                      sizeof(time_T)*1);

23882
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

23883
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

23884
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

23885


23886
        /* Set up the mdlInfo pointer */

23887
# ifdef USE_RTMODEL

23888


23889
        {

23890
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

23891
              struct _ssBlkInfo2));

23892
          ss_VALIDATE_MEMORY(rts,blkInfo2);

23893
          ssSetBlkInfo2Ptr(childS, blkInfo2);

23894
        }

23895


23896
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

23897


23898
# else

23899


23900
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

23901


23902
# endif                                /* USE_RTMODEL */

23903


23904
        /* Allocate memory of model methods 2 */

23905
        {

23906
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

23907
            malloc(sizeof(struct _ssSFcnModelMethods2));

23908
          ss_VALIDATE_MEMORY(rts,methods2);

23909
          ssSetModelMethods2(childS, methods2);

23910
        }

23911


23912
        /* Allocate memory of model methods 3 */

23913
        {

23914
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

23915
            malloc(sizeof(struct _ssSFcnModelMethods3));

23916
          ss_VALIDATE_MEMORY(rts,methods3);

23917
          ssSetModelMethods3(childS, methods3);

23918
        }

23919


23920
        /* Allocate memory for states auxilliary information */

23921
        {

23922
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

23923
            (sizeof(struct _ssStatesInfo2));

23924
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

23925
            malloc(sizeof(ssPeriodicStatesInfo));

23926
          ss_VALIDATE_MEMORY(rts,statesInfo2);

23927
          ssSetStatesInfo2(childS, statesInfo2);

23928
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

23929
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

23930
        }

23931


23932
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

23933
          RegNumInputPorts);

23934
        ssSetRegNumInputPortsFcnArg(childS,childS);

23935


23936
        /* inputs */

23937
        {

23938
          struct _ssPortInputs *inputPortInfo =

23939
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

23940
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

23941
          _ssSetNumInputPorts(childS, 3);

23942
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

23943


23944
          /* port 0 */

23945
          {

23946
            real32_T const **sfcnUPtrs = (real32_T const **)

23947
              malloc(1 * sizeof(real32_T *));

23948
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23949
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

23950
              ssGetLocalBlockIO(rts))->GeneratedSFunction_mc;

23951
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

23952
            _ssSetInputPortNumDimensions(childS, 0, 1);

23953
            ssSetInputPortWidth(childS, 0, 1);

23954
          }

23955


23956
          /* port 1 */

23957
          {

23958
            real32_T const **sfcnUPtrs = (real32_T const **)

23959
              malloc(1 * sizeof(real32_T *));

23960
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23961
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

23962
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

23963
            _ssSetInputPortNumDimensions(childS, 1, 1);

23964
            ssSetInputPortWidth(childS, 1, 1);

23965
          }

23966


23967
          /* port 2 */

23968
          {

23969
            real32_T const **sfcnUPtrs = (real32_T const **)

23970
              malloc(1 * sizeof(real32_T *));

23971
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

23972
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

23973
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

23974
            _ssSetInputPortNumDimensions(childS, 2, 1);

23975
            ssSetInputPortWidth(childS, 2, 1);

23976
          }

23977
        }

23978


23979
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

23980
          RegNumOutputPorts);

23981
        ssSetRegNumOutputPortsFcnArg(childS,childS);

23982


23983
        /* outputs */

23984
        {

23985
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

23986
            calloc(1, sizeof(struct _ssPortOutputs));

23987
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

23988
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

23989
          _ssSetNumOutputPorts(childS, 1);

23990


23991
          /* port 0 */

23992
          {

23993
            _ssSetOutputPortNumDimensions(childS, 0, 1);

23994
            ssSetOutputPortWidth(childS, 0, 1);

23995
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

23996
              ssGetLocalBlockIO(rts))->Saturation2_p));

23997
          }

23998
        }

23999


24000
        /* path info */

24001
        _ssSetModelName(childS, "SaturationLimiter_sf");

24002
        _ssSetPath(childS,

24003
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter/Generated S-Function1");

24004
        if (ssGetRTModel(rts) == (NULL)) {

24005
          _ssSetParentSS(childS, rts);

24006
          _ssSetRootSS(childS, ssGetRootSS(rts));

24007
        } else {

24008
          ssSetRTModel(childS,ssGetRTModel(rts));

24009
          _ssSetParentSS(childS, (NULL));

24010
          _ssSetRootSS(childS, childS);

24011
        }

24012


24013
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

24014
        (childS)->regDataType.arg1 = ((void *)(childS));

24015
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

24016
          FcnSetErrorStatus);

24017
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

24018
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

24019
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

24020
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

24021


24022
        /* registration */

24023
#if defined(MATLAB_MEX_FILE)

24024


24025
        {

24026
          int_T i;

24027
          mxArray *plhs[1];

24028
          mxArray *prhs[4];

24029
          double *pr;

24030
          volatile int_T *intS = (int_T *)&childS;

24031
          int_T addrlen = sizeof(SimStruct *);

24032
          int_T m = addrlen/sizeof(int_T) + 1;

24033
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

24034
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

24035
          pr = mxGetPr(prhs[1]);

24036
          for (i = 0; i < m - 1; i++) {

24037
            pr[i] = (double)intS[i];

24038
          }

24039


24040
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

24041
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

24042
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

24043


24044
          /* Reset port dimensions info functions because the S-function

24045
           * and accelerator mex-files explicitly set their dimensions,

24046
           * i.e., they are not dynamically sized. For this case, the

24047
           * mex-file is responsible for the dimensions info memory

24048
           * and Simulink should not free it. This is achieved by

24049
           * setting the following two methods to NULL.

24050
           */

24051
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

24052
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

24053


24054
          /*

24055
           * Setup function pointers and call mdlInitializeSizes via

24056
           * simulink.c

24057
           */

24058
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

24059
          mxDestroyArray(plhs[0]);

24060
          mxDestroyArray(prhs[0]);

24061
          mxDestroyArray(prhs[1]);

24062
          mxDestroyArray(prhs[2]);

24063
          mxDestroyArray(prhs[3]);

24064
        }

24065


24066
#else

24067


24068
        {

24069
          SaturationLimiter_sf(childS);

24070
          sfcnInitializeSizes(childS);

24071
        }

24072


24073
#endif

24074


24075
        sfcnInitializeSampleTimes(childS);

24076


24077
        /* adjust sample time */

24078
        ssSetSampleTime(childS, 0, 0.0);

24079
        ssSetOffsetTime(childS, 0, 0.0);

24080
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

24081


24082
        /* set compiled values of dynamic vector attributes */

24083
        ssSetNumNonsampledZCs(childS, 0);

24084


24085
        /* Update connectivity flags for each port */

24086
        _ssSetInputPortConnected(childS, 0, 1);

24087
        _ssSetInputPortConnected(childS, 1, 1);

24088
        _ssSetInputPortConnected(childS, 2, 1);

24089
        _ssSetOutputPortConnected(childS, 0, 1);

24090
        _ssSetOutputPortBeingMerged(childS, 0, 0);

24091


24092
        /* Update the BufferDstPort flags for each input port */

24093
        _ssSetInputPortBufferDstPort(childS, 0, -1);

24094
        _ssSetInputPortBufferDstPort(childS, 1, -1);

24095
        _ssSetInputPortBufferDstPort(childS, 2, -1);

24096
      }

24097


24098
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S129>/Generated S-Function1 (Res180_sf) */

24099
      {

24100
        SimStruct *childS = ssGetSFunction(rts, 91);

24101


24102
        /* timing info */

24103
        time_T *sfcnPeriod;

24104
        time_T *sfcnOffset;

24105
        int_T *sfcnTsMap;

24106
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

24107
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

24108
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

24109
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

24110
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

24111
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

24112
        (void) memset((void*)sfcnPeriod, 0,

24113
                      sizeof(time_T)*1);

24114
        (void) memset((void*)sfcnOffset, 0,

24115
                      sizeof(time_T)*1);

24116
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

24117
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

24118
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

24119


24120
        /* Set up the mdlInfo pointer */

24121
# ifdef USE_RTMODEL

24122


24123
        {

24124
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

24125
              struct _ssBlkInfo2));

24126
          ss_VALIDATE_MEMORY(rts,blkInfo2);

24127
          ssSetBlkInfo2Ptr(childS, blkInfo2);

24128
        }

24129


24130
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

24131


24132
# else

24133


24134
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

24135


24136
# endif                                /* USE_RTMODEL */

24137


24138
        /* Allocate memory of model methods 2 */

24139
        {

24140
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

24141
            malloc(sizeof(struct _ssSFcnModelMethods2));

24142
          ss_VALIDATE_MEMORY(rts,methods2);

24143
          ssSetModelMethods2(childS, methods2);

24144
        }

24145


24146
        /* Allocate memory of model methods 3 */

24147
        {

24148
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

24149
            malloc(sizeof(struct _ssSFcnModelMethods3));

24150
          ss_VALIDATE_MEMORY(rts,methods3);

24151
          ssSetModelMethods3(childS, methods3);

24152
        }

24153


24154
        /* Allocate memory for states auxilliary information */

24155
        {

24156
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

24157
            (sizeof(struct _ssStatesInfo2));

24158
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

24159
            malloc(sizeof(ssPeriodicStatesInfo));

24160
          ss_VALIDATE_MEMORY(rts,statesInfo2);

24161
          ssSetStatesInfo2(childS, statesInfo2);

24162
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

24163
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

24164
        }

24165


24166
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

24167
          RegNumInputPorts);

24168
        ssSetRegNumInputPortsFcnArg(childS,childS);

24169


24170
        /* inputs */

24171
        {

24172
          struct _ssPortInputs *inputPortInfo =

24173
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

24174
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

24175
          _ssSetNumInputPorts(childS, 1);

24176
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

24177


24178
          /* port 0 */

24179
          {

24180
            real32_T const **sfcnUPtrs = (real32_T const **)

24181
              malloc(1 * sizeof(real32_T *));

24182
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24183
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24184
              ssGetLocalBlockIO(rts))->Sum1_lk;

24185
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

24186
            _ssSetInputPortNumDimensions(childS, 0, 1);

24187
            ssSetInputPortWidth(childS, 0, 1);

24188
          }

24189
        }

24190


24191
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

24192
          RegNumOutputPorts);

24193
        ssSetRegNumOutputPortsFcnArg(childS,childS);

24194


24195
        /* outputs */

24196
        {

24197
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

24198
            calloc(1, sizeof(struct _ssPortOutputs));

24199
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

24200
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

24201
          _ssSetNumOutputPorts(childS, 1);

24202


24203
          /* port 0 */

24204
          {

24205
            _ssSetOutputPortNumDimensions(childS, 0, 1);

24206
            ssSetOutputPortWidth(childS, 0, 1);

24207
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

24208
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_f));

24209
          }

24210
        }

24211


24212
        /* path info */

24213
        _ssSetModelName(childS, "Res180_sf");

24214
        _ssSetPath(childS,

24215
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Generated S-Function1");

24216
        if (ssGetRTModel(rts) == (NULL)) {

24217
          _ssSetParentSS(childS, rts);

24218
          _ssSetRootSS(childS, ssGetRootSS(rts));

24219
        } else {

24220
          ssSetRTModel(childS,ssGetRTModel(rts));

24221
          _ssSetParentSS(childS, (NULL));

24222
          _ssSetRootSS(childS, childS);

24223
        }

24224


24225
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

24226
        (childS)->regDataType.arg1 = ((void *)(childS));

24227
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

24228
          FcnSetErrorStatus);

24229
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

24230
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

24231
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

24232
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

24233


24234
        /* registration */

24235
#if defined(MATLAB_MEX_FILE)

24236


24237
        {

24238
          int_T i;

24239
          mxArray *plhs[1];

24240
          mxArray *prhs[4];

24241
          double *pr;

24242
          volatile int_T *intS = (int_T *)&childS;

24243
          int_T addrlen = sizeof(SimStruct *);

24244
          int_T m = addrlen/sizeof(int_T) + 1;

24245
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

24246
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

24247
          pr = mxGetPr(prhs[1]);

24248
          for (i = 0; i < m - 1; i++) {

24249
            pr[i] = (double)intS[i];

24250
          }

24251


24252
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

24253
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

24254
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

24255


24256
          /* Reset port dimensions info functions because the S-function

24257
           * and accelerator mex-files explicitly set their dimensions,

24258
           * i.e., they are not dynamically sized. For this case, the

24259
           * mex-file is responsible for the dimensions info memory

24260
           * and Simulink should not free it. This is achieved by

24261
           * setting the following two methods to NULL.

24262
           */

24263
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

24264
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

24265


24266
          /*

24267
           * Setup function pointers and call mdlInitializeSizes via

24268
           * simulink.c

24269
           */

24270
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

24271
          mxDestroyArray(plhs[0]);

24272
          mxDestroyArray(prhs[0]);

24273
          mxDestroyArray(prhs[1]);

24274
          mxDestroyArray(prhs[2]);

24275
          mxDestroyArray(prhs[3]);

24276
        }

24277


24278
#else

24279


24280
        {

24281
          Res180_sf(childS);

24282
          sfcnInitializeSizes(childS);

24283
        }

24284


24285
#endif

24286


24287
        sfcnInitializeSampleTimes(childS);

24288


24289
        /* adjust sample time */

24290
        ssSetSampleTime(childS, 0, 0.0);

24291
        ssSetOffsetTime(childS, 0, 0.0);

24292
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

24293


24294
        /* set compiled values of dynamic vector attributes */

24295
        ssSetNumNonsampledZCs(childS, 0);

24296


24297
        /* Update connectivity flags for each port */

24298
        _ssSetInputPortConnected(childS, 0, 1);

24299
        _ssSetOutputPortConnected(childS, 0, 1);

24300
        _ssSetOutputPortBeingMerged(childS, 0, 0);

24301


24302
        /* Update the BufferDstPort flags for each input port */

24303
        _ssSetInputPortBufferDstPort(childS, 0, -1);

24304
      }

24305


24306
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S166>/Generated S-Function (Gain_sf) */

24307
      {

24308
        SimStruct *childS = ssGetSFunction(rts, 92);

24309


24310
        /* timing info */

24311
        time_T *sfcnPeriod;

24312
        time_T *sfcnOffset;

24313
        int_T *sfcnTsMap;

24314
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

24315
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

24316
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

24317
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

24318
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

24319
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

24320
        (void) memset((void*)sfcnPeriod, 0,

24321
                      sizeof(time_T)*1);

24322
        (void) memset((void*)sfcnOffset, 0,

24323
                      sizeof(time_T)*1);

24324
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

24325
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

24326
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

24327


24328
        /* Set up the mdlInfo pointer */

24329
# ifdef USE_RTMODEL

24330


24331
        {

24332
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

24333
              struct _ssBlkInfo2));

24334
          ss_VALIDATE_MEMORY(rts,blkInfo2);

24335
          ssSetBlkInfo2Ptr(childS, blkInfo2);

24336
        }

24337


24338
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

24339


24340
# else

24341


24342
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

24343


24344
# endif                                /* USE_RTMODEL */

24345


24346
        /* Allocate memory of model methods 2 */

24347
        {

24348
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

24349
            malloc(sizeof(struct _ssSFcnModelMethods2));

24350
          ss_VALIDATE_MEMORY(rts,methods2);

24351
          ssSetModelMethods2(childS, methods2);

24352
        }

24353


24354
        /* Allocate memory of model methods 3 */

24355
        {

24356
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

24357
            malloc(sizeof(struct _ssSFcnModelMethods3));

24358
          ss_VALIDATE_MEMORY(rts,methods3);

24359
          ssSetModelMethods3(childS, methods3);

24360
        }

24361


24362
        /* Allocate memory for states auxilliary information */

24363
        {

24364
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

24365
            (sizeof(struct _ssStatesInfo2));

24366
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

24367
            malloc(sizeof(ssPeriodicStatesInfo));

24368
          ss_VALIDATE_MEMORY(rts,statesInfo2);

24369
          ssSetStatesInfo2(childS, statesInfo2);

24370
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

24371
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

24372
        }

24373


24374
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

24375
          RegNumInputPorts);

24376
        ssSetRegNumInputPortsFcnArg(childS,childS);

24377


24378
        /* inputs */

24379
        {

24380
          struct _ssPortInputs *inputPortInfo =

24381
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

24382
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

24383
          _ssSetNumInputPorts(childS, 2);

24384
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

24385


24386
          /* port 0 */

24387
          {

24388
            real32_T const **sfcnUPtrs = (real32_T const **)

24389
              malloc(1 * sizeof(real32_T *));

24390
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24391
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24392
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_f;

24393
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

24394
            _ssSetInputPortNumDimensions(childS, 0, 1);

24395
            ssSetInputPortWidth(childS, 0, 1);

24396
          }

24397


24398
          /* port 1 */

24399
          {

24400
            real32_T const **sfcnUPtrs = (real32_T const **)

24401
              malloc(1 * sizeof(real32_T *));

24402
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24403
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

24404
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

24405
            _ssSetInputPortNumDimensions(childS, 1, 1);

24406
            ssSetInputPortWidth(childS, 1, 1);

24407
          }

24408
        }

24409


24410
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

24411
          RegNumOutputPorts);

24412
        ssSetRegNumOutputPortsFcnArg(childS,childS);

24413


24414
        /* outputs */

24415
        {

24416
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

24417
            calloc(1, sizeof(struct _ssPortOutputs));

24418
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

24419
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

24420
          _ssSetNumOutputPorts(childS, 1);

24421


24422
          /* port 0 */

24423
          {

24424
            _ssSetOutputPortNumDimensions(childS, 0, 1);

24425
            ssSetOutputPortWidth(childS, 0, 1);

24426
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

24427
              ssGetLocalBlockIO(rts))->Saturation2_p));

24428
          }

24429
        }

24430


24431
        /* path info */

24432
        _ssSetModelName(childS, "Gain_sf");

24433
        _ssSetPath(childS,

24434
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain/Generated S-Function");

24435
        if (ssGetRTModel(rts) == (NULL)) {

24436
          _ssSetParentSS(childS, rts);

24437
          _ssSetRootSS(childS, ssGetRootSS(rts));

24438
        } else {

24439
          ssSetRTModel(childS,ssGetRTModel(rts));

24440
          _ssSetParentSS(childS, (NULL));

24441
          _ssSetRootSS(childS, childS);

24442
        }

24443


24444
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

24445
        (childS)->regDataType.arg1 = ((void *)(childS));

24446
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

24447
          FcnSetErrorStatus);

24448
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

24449
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

24450
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

24451
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

24452


24453
        /* registration */

24454
#if defined(MATLAB_MEX_FILE)

24455


24456
        {

24457
          int_T i;

24458
          mxArray *plhs[1];

24459
          mxArray *prhs[4];

24460
          double *pr;

24461
          volatile int_T *intS = (int_T *)&childS;

24462
          int_T addrlen = sizeof(SimStruct *);

24463
          int_T m = addrlen/sizeof(int_T) + 1;

24464
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

24465
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

24466
          pr = mxGetPr(prhs[1]);

24467
          for (i = 0; i < m - 1; i++) {

24468
            pr[i] = (double)intS[i];

24469
          }

24470


24471
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

24472
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

24473
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

24474


24475
          /* Reset port dimensions info functions because the S-function

24476
           * and accelerator mex-files explicitly set their dimensions,

24477
           * i.e., they are not dynamically sized. For this case, the

24478
           * mex-file is responsible for the dimensions info memory

24479
           * and Simulink should not free it. This is achieved by

24480
           * setting the following two methods to NULL.

24481
           */

24482
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

24483
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

24484


24485
          /*

24486
           * Setup function pointers and call mdlInitializeSizes via

24487
           * simulink.c

24488
           */

24489
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

24490
          mxDestroyArray(plhs[0]);

24491
          mxDestroyArray(prhs[0]);

24492
          mxDestroyArray(prhs[1]);

24493
          mxDestroyArray(prhs[2]);

24494
          mxDestroyArray(prhs[3]);

24495
        }

24496


24497
#else

24498


24499
        {

24500
          Gain_sf(childS);

24501
          sfcnInitializeSizes(childS);

24502
        }

24503


24504
#endif

24505


24506
        sfcnInitializeSampleTimes(childS);

24507


24508
        /* adjust sample time */

24509
        ssSetSampleTime(childS, 0, 0.0);

24510
        ssSetOffsetTime(childS, 0, 0.0);

24511
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

24512


24513
        /* set compiled values of dynamic vector attributes */

24514
        ssSetNumNonsampledZCs(childS, 0);

24515


24516
        /* Update connectivity flags for each port */

24517
        _ssSetInputPortConnected(childS, 0, 1);

24518
        _ssSetInputPortConnected(childS, 1, 1);

24519
        _ssSetOutputPortConnected(childS, 0, 1);

24520
        _ssSetOutputPortBeingMerged(childS, 0, 0);

24521


24522
        /* Update the BufferDstPort flags for each input port */

24523
        _ssSetInputPortBufferDstPort(childS, 0, -1);

24524
        _ssSetInputPortBufferDstPort(childS, 1, -1);

24525
      }

24526


24527
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S159>/Generated S-Function4 (LagFilter_sf) */

24528
      {

24529
        SimStruct *childS = ssGetSFunction(rts, 93);

24530


24531
        /* timing info */

24532
        time_T *sfcnPeriod;

24533
        time_T *sfcnOffset;

24534
        int_T *sfcnTsMap;

24535
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

24536
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

24537
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

24538
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

24539
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

24540
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

24541
        (void) memset((void*)sfcnPeriod, 0,

24542
                      sizeof(time_T)*1);

24543
        (void) memset((void*)sfcnOffset, 0,

24544
                      sizeof(time_T)*1);

24545
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

24546
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

24547
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

24548


24549
        /* Set up the mdlInfo pointer */

24550
# ifdef USE_RTMODEL

24551


24552
        {

24553
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

24554
              struct _ssBlkInfo2));

24555
          ss_VALIDATE_MEMORY(rts,blkInfo2);

24556
          ssSetBlkInfo2Ptr(childS, blkInfo2);

24557
        }

24558


24559
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

24560


24561
# else

24562


24563
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

24564


24565
# endif                                /* USE_RTMODEL */

24566


24567
        /* Allocate memory of model methods 2 */

24568
        {

24569
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

24570
            malloc(sizeof(struct _ssSFcnModelMethods2));

24571
          ss_VALIDATE_MEMORY(rts,methods2);

24572
          ssSetModelMethods2(childS, methods2);

24573
        }

24574


24575
        /* Allocate memory of model methods 3 */

24576
        {

24577
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

24578
            malloc(sizeof(struct _ssSFcnModelMethods3));

24579
          ss_VALIDATE_MEMORY(rts,methods3);

24580
          ssSetModelMethods3(childS, methods3);

24581
        }

24582


24583
        /* Allocate memory for states auxilliary information */

24584
        {

24585
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

24586
            (sizeof(struct _ssStatesInfo2));

24587
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

24588
            malloc(sizeof(ssPeriodicStatesInfo));

24589
          ss_VALIDATE_MEMORY(rts,statesInfo2);

24590
          ssSetStatesInfo2(childS, statesInfo2);

24591
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

24592
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

24593
        }

24594


24595
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

24596
          RegNumInputPorts);

24597
        ssSetRegNumInputPortsFcnArg(childS,childS);

24598


24599
        /* inputs */

24600
        {

24601
          struct _ssPortInputs *inputPortInfo =

24602
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

24603
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

24604
          _ssSetNumInputPorts(childS, 6);

24605
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

24606


24607
          /* port 0 */

24608
          {

24609
            real32_T const **sfcnUPtrs = (real32_T const **)

24610
              malloc(1 * sizeof(real32_T *));

24611
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24612
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24613
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

24614
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

24615
            _ssSetInputPortNumDimensions(childS, 0, 1);

24616
            ssSetInputPortWidth(childS, 0, 1);

24617
          }

24618


24619
          /* port 1 */

24620
          {

24621
            int8_T const **sfcnUPtrs = (int8_T const **)

24622
              malloc(1 * sizeof(int8_T *));

24623
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24624
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

24625
              ssGetLocalBlockIO(rts))->DataTypeConversion4_g;

24626
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

24627
            _ssSetInputPortNumDimensions(childS, 1, 1);

24628
            ssSetInputPortWidth(childS, 1, 1);

24629
          }

24630


24631
          /* port 2 */

24632
          {

24633
            real32_T const **sfcnUPtrs = (real32_T const **)

24634
              malloc(1 * sizeof(real32_T *));

24635
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24636
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

24637
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

24638
            _ssSetInputPortNumDimensions(childS, 2, 1);

24639
            ssSetInputPortWidth(childS, 2, 1);

24640
          }

24641


24642
          /* port 3 */

24643
          {

24644
            real32_T const **sfcnUPtrs = (real32_T const **)

24645
              malloc(1 * sizeof(real32_T *));

24646
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24647
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24648
              ssGetLocalBlockIO(rts))->Switch_bg;

24649
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

24650
            _ssSetInputPortNumDimensions(childS, 3, 1);

24651
            ssSetInputPortWidth(childS, 3, 1);

24652
          }

24653


24654
          /* port 4 */

24655
          {

24656
            real32_T const **sfcnUPtrs = (real32_T const **)

24657
              malloc(1 * sizeof(real32_T *));

24658
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24659
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24660
              ssGetLocalBlockIO(rts))->Switch_bg;

24661
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

24662
            _ssSetInputPortNumDimensions(childS, 4, 1);

24663
            ssSetInputPortWidth(childS, 4, 1);

24664
          }

24665


24666
          /* port 5 */

24667
          {

24668
            real32_T const **sfcnUPtrs = (real32_T const **)

24669
              malloc(1 * sizeof(real32_T *));

24670
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24671
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24672
              ssGetLocalBlockIO(rts))->Sum_oh;

24673
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

24674
            _ssSetInputPortNumDimensions(childS, 5, 1);

24675
            ssSetInputPortWidth(childS, 5, 1);

24676
          }

24677
        }

24678


24679
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

24680
          RegNumOutputPorts);

24681
        ssSetRegNumOutputPortsFcnArg(childS,childS);

24682


24683
        /* outputs */

24684
        {

24685
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

24686
            calloc(1, sizeof(struct _ssPortOutputs));

24687
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

24688
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

24689
          _ssSetNumOutputPorts(childS, 1);

24690


24691
          /* port 0 */

24692
          {

24693
            _ssSetOutputPortNumDimensions(childS, 0, 1);

24694
            ssSetOutputPortWidth(childS, 0, 1);

24695
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

24696
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_mj));

24697
          }

24698
        }

24699


24700
        /* path info */

24701
        _ssSetModelName(childS, "LagFilter_sf");

24702
        _ssSetPath(childS,

24703
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/ lag filter/Generated S-Function4");

24704
        if (ssGetRTModel(rts) == (NULL)) {

24705
          _ssSetParentSS(childS, rts);

24706
          _ssSetRootSS(childS, ssGetRootSS(rts));

24707
        } else {

24708
          ssSetRTModel(childS,ssGetRTModel(rts));

24709
          _ssSetParentSS(childS, (NULL));

24710
          _ssSetRootSS(childS, childS);

24711
        }

24712


24713
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

24714


24715
        /* work vectors */

24716
        {

24717
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

24718
            (4 * sizeof(struct _ssDWorkRecord));

24719
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

24720
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

24721
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

24722
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

24723
          ssSetSFcnDWork(childS, dWorkRecord);

24724
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

24725
          _ssSetNumDWork(childS, 4);

24726


24727
          /* DWORK0 */

24728
          ssSetDWorkWidth(childS, 0, 1);

24729
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

24730
          ssSetDWorkComplexSignal(childS, 0, 0);

24731
          ssSetDWorkUsedAsDState(childS, 0, 1);

24732
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 216))[0]);

24733


24734
          /* DWORK1 */

24735
          ssSetDWorkWidth(childS, 1, 1);

24736
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

24737
          ssSetDWorkComplexSignal(childS, 1, 0);

24738
          ssSetDWorkUsedAsDState(childS, 1, 1);

24739
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 217))[0]);

24740


24741
          /* DWORK2 */

24742
          ssSetDWorkWidth(childS, 2, 1);

24743
          ssSetDWorkDataType(childS, 2,SS_INT8);

24744
          ssSetDWorkComplexSignal(childS, 2, 0);

24745
          ssSetDWorkUsedAsDState(childS, 2, 1);

24746
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 443))[0]);

24747


24748
          /* DWORK3 */

24749
          ssSetDWorkWidth(childS, 3, 1);

24750
          ssSetDWorkDataType(childS, 3,SS_INT8);

24751
          ssSetDWorkComplexSignal(childS, 3, 0);

24752
          ssSetDWorkUsedAsDState(childS, 3, 1);

24753
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 444))[0]);

24754
        }

24755


24756
        (childS)->regDataType.arg1 = ((void *)(childS));

24757
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

24758
          FcnSetErrorStatus);

24759
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

24760
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

24761
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

24762
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

24763


24764
        /* registration */

24765
#if defined(MATLAB_MEX_FILE)

24766


24767
        {

24768
          int_T i;

24769
          mxArray *plhs[1];

24770
          mxArray *prhs[4];

24771
          double *pr;

24772
          volatile int_T *intS = (int_T *)&childS;

24773
          int_T addrlen = sizeof(SimStruct *);

24774
          int_T m = addrlen/sizeof(int_T) + 1;

24775
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

24776
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

24777
          pr = mxGetPr(prhs[1]);

24778
          for (i = 0; i < m - 1; i++) {

24779
            pr[i] = (double)intS[i];

24780
          }

24781


24782
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

24783
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

24784
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

24785


24786
          /* Reset port dimensions info functions because the S-function

24787
           * and accelerator mex-files explicitly set their dimensions,

24788
           * i.e., they are not dynamically sized. For this case, the

24789
           * mex-file is responsible for the dimensions info memory

24790
           * and Simulink should not free it. This is achieved by

24791
           * setting the following two methods to NULL.

24792
           */

24793
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

24794
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

24795


24796
          /*

24797
           * Setup function pointers and call mdlInitializeSizes via

24798
           * simulink.c

24799
           */

24800
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

24801
          mxDestroyArray(plhs[0]);

24802
          mxDestroyArray(prhs[0]);

24803
          mxDestroyArray(prhs[1]);

24804
          mxDestroyArray(prhs[2]);

24805
          mxDestroyArray(prhs[3]);

24806
        }

24807


24808
#else

24809


24810
        {

24811
          LagFilter_sf(childS);

24812
          sfcnInitializeSizes(childS);

24813
        }

24814


24815
#endif

24816


24817
        sfcnInitializeSampleTimes(childS);

24818


24819
        /* adjust sample time */

24820
        ssSetSampleTime(childS, 0, 0.0);

24821
        ssSetOffsetTime(childS, 0, 0.0);

24822
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

24823


24824
        /* set compiled values of dynamic vector attributes */

24825
        ssSetNumNonsampledZCs(childS, 0);

24826


24827
        /* Update connectivity flags for each port */

24828
        _ssSetInputPortConnected(childS, 0, 1);

24829
        _ssSetInputPortConnected(childS, 1, 1);

24830
        _ssSetInputPortConnected(childS, 2, 1);

24831
        _ssSetInputPortConnected(childS, 3, 1);

24832
        _ssSetInputPortConnected(childS, 4, 1);

24833
        _ssSetInputPortConnected(childS, 5, 1);

24834
        _ssSetOutputPortConnected(childS, 0, 1);

24835
        _ssSetOutputPortBeingMerged(childS, 0, 0);

24836


24837
        /* Update the BufferDstPort flags for each input port */

24838
        _ssSetInputPortBufferDstPort(childS, 0, -1);

24839
        _ssSetInputPortBufferDstPort(childS, 1, -1);

24840
        _ssSetInputPortBufferDstPort(childS, 2, -1);

24841
        _ssSetInputPortBufferDstPort(childS, 3, -1);

24842
        _ssSetInputPortBufferDstPort(childS, 4, -1);

24843
        _ssSetInputPortBufferDstPort(childS, 5, -1);

24844
      }

24845


24846
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S123>/Generated S-Function5 (Fader_sf) */

24847
      {

24848
        SimStruct *childS = ssGetSFunction(rts, 94);

24849


24850
        /* timing info */

24851
        time_T *sfcnPeriod;

24852
        time_T *sfcnOffset;

24853
        int_T *sfcnTsMap;

24854
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

24855
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

24856
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

24857
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

24858
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

24859
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

24860
        (void) memset((void*)sfcnPeriod, 0,

24861
                      sizeof(time_T)*1);

24862
        (void) memset((void*)sfcnOffset, 0,

24863
                      sizeof(time_T)*1);

24864
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

24865
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

24866
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

24867


24868
        /* Set up the mdlInfo pointer */

24869
# ifdef USE_RTMODEL

24870


24871
        {

24872
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

24873
              struct _ssBlkInfo2));

24874
          ss_VALIDATE_MEMORY(rts,blkInfo2);

24875
          ssSetBlkInfo2Ptr(childS, blkInfo2);

24876
        }

24877


24878
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

24879


24880
# else

24881


24882
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

24883


24884
# endif                                /* USE_RTMODEL */

24885


24886
        /* Allocate memory of model methods 2 */

24887
        {

24888
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

24889
            malloc(sizeof(struct _ssSFcnModelMethods2));

24890
          ss_VALIDATE_MEMORY(rts,methods2);

24891
          ssSetModelMethods2(childS, methods2);

24892
        }

24893


24894
        /* Allocate memory of model methods 3 */

24895
        {

24896
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

24897
            malloc(sizeof(struct _ssSFcnModelMethods3));

24898
          ss_VALIDATE_MEMORY(rts,methods3);

24899
          ssSetModelMethods3(childS, methods3);

24900
        }

24901


24902
        /* Allocate memory for states auxilliary information */

24903
        {

24904
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

24905
            (sizeof(struct _ssStatesInfo2));

24906
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

24907
            malloc(sizeof(ssPeriodicStatesInfo));

24908
          ss_VALIDATE_MEMORY(rts,statesInfo2);

24909
          ssSetStatesInfo2(childS, statesInfo2);

24910
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

24911
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

24912
        }

24913


24914
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

24915
          RegNumInputPorts);

24916
        ssSetRegNumInputPortsFcnArg(childS,childS);

24917


24918
        /* inputs */

24919
        {

24920
          struct _ssPortInputs *inputPortInfo =

24921
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

24922
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

24923
          _ssSetNumInputPorts(childS, 6);

24924
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

24925


24926
          /* port 0 */

24927
          {

24928
            real32_T const **sfcnUPtrs = (real32_T const **)

24929
              malloc(1 * sizeof(real32_T *));

24930
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24931
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24932
              ssGetLocalBlockIO(rts))->MultiportSwitch2_k;

24933
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

24934
            _ssSetInputPortNumDimensions(childS, 0, 1);

24935
            ssSetInputPortWidth(childS, 0, 1);

24936
          }

24937


24938
          /* port 1 */

24939
          {

24940
            real32_T const **sfcnUPtrs = (real32_T const **)

24941
              malloc(1 * sizeof(real32_T *));

24942
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24943
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24944
              ssGetLocalBlockIO(rts))->MultiportSwitch2_k;

24945
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

24946
            _ssSetInputPortNumDimensions(childS, 1, 1);

24947
            ssSetInputPortWidth(childS, 1, 1);

24948
          }

24949


24950
          /* port 2 */

24951
          {

24952
            int8_T const **sfcnUPtrs = (int8_T const **)

24953
              malloc(1 * sizeof(int8_T *));

24954
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24955
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

24956
              ssGetLocalBlockIO(rts))->Switch9;

24957
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

24958
            _ssSetInputPortNumDimensions(childS, 2, 1);

24959
            ssSetInputPortWidth(childS, 2, 1);

24960
          }

24961


24962
          /* port 3 */

24963
          {

24964
            int8_T const **sfcnUPtrs = (int8_T const **)

24965
              malloc(1 * sizeof(int8_T *));

24966
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24967
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

24968
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

24969
            _ssSetInputPortNumDimensions(childS, 3, 1);

24970
            ssSetInputPortWidth(childS, 3, 1);

24971
          }

24972


24973
          /* port 4 */

24974
          {

24975
            real32_T const **sfcnUPtrs = (real32_T const **)

24976
              malloc(1 * sizeof(real32_T *));

24977
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24978
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

24979
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

24980
            _ssSetInputPortNumDimensions(childS, 4, 1);

24981
            ssSetInputPortWidth(childS, 4, 1);

24982
          }

24983


24984
          /* port 5 */

24985
          {

24986
            real32_T const **sfcnUPtrs = (real32_T const **)

24987
              malloc(1 * sizeof(real32_T *));

24988
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

24989
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

24990
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

24991
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

24992
            _ssSetInputPortNumDimensions(childS, 5, 1);

24993
            ssSetInputPortWidth(childS, 5, 1);

24994
          }

24995
        }

24996


24997
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

24998
          RegNumOutputPorts);

24999
        ssSetRegNumOutputPortsFcnArg(childS,childS);

25000


25001
        /* outputs */

25002
        {

25003
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

25004
            calloc(1, sizeof(struct _ssPortOutputs));

25005
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

25006
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

25007
          _ssSetNumOutputPorts(childS, 1);

25008


25009
          /* port 0 */

25010
          {

25011
            _ssSetOutputPortNumDimensions(childS, 0, 1);

25012
            ssSetOutputPortWidth(childS, 0, 1);

25013
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

25014
              ssGetLocalBlockIO(rts))->aprc));

25015
          }

25016
        }

25017


25018
        /* path info */

25019
        _ssSetModelName(childS, "Fader_sf");

25020
        _ssSetPath(childS,

25021
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/Fader/Generated S-Function5");

25022
        if (ssGetRTModel(rts) == (NULL)) {

25023
          _ssSetParentSS(childS, rts);

25024
          _ssSetRootSS(childS, ssGetRootSS(rts));

25025
        } else {

25026
          ssSetRTModel(childS,ssGetRTModel(rts));

25027
          _ssSetParentSS(childS, (NULL));

25028
          _ssSetRootSS(childS, childS);

25029
        }

25030


25031
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

25032


25033
        /* work vectors */

25034
        {

25035
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

25036
            (7 * sizeof(struct _ssDWorkRecord));

25037
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

25038
            calloc(7, sizeof(struct _ssDWorkAuxRecord));

25039
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

25040
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

25041
          ssSetSFcnDWork(childS, dWorkRecord);

25042
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

25043
          _ssSetNumDWork(childS, 7);

25044


25045
          /* DWORK0 */

25046
          ssSetDWorkWidth(childS, 0, 1);

25047
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

25048
          ssSetDWorkComplexSignal(childS, 0, 0);

25049
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 292))[0]);

25050


25051
          /* DWORK1 */

25052
          ssSetDWorkWidth(childS, 1, 1);

25053
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

25054
          ssSetDWorkComplexSignal(childS, 1, 0);

25055
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 293))[0]);

25056


25057
          /* DWORK2 */

25058
          ssSetDWorkWidth(childS, 2, 1);

25059
          ssSetDWorkDataType(childS, 2,SS_SINGLE);

25060
          ssSetDWorkComplexSignal(childS, 2, 0);

25061
          _ssSetDWork(childS, 2, &((real32_T*) ssGetDWork(rts, 294))[0]);

25062


25063
          /* DWORK3 */

25064
          ssSetDWorkWidth(childS, 3, 1);

25065
          ssSetDWorkDataType(childS, 3,SS_INT32);

25066
          ssSetDWorkComplexSignal(childS, 3, 0);

25067
          _ssSetDWork(childS, 3, &((int32_T*) ssGetDWork(rts, 334))[0]);

25068


25069
          /* DWORK4 */

25070
          ssSetDWorkWidth(childS, 4, 1);

25071
          ssSetDWorkDataType(childS, 4,SS_INT32);

25072
          ssSetDWorkComplexSignal(childS, 4, 0);

25073
          _ssSetDWork(childS, 4, &((int32_T*) ssGetDWork(rts, 335))[0]);

25074


25075
          /* DWORK5 */

25076
          ssSetDWorkWidth(childS, 5, 1);

25077
          ssSetDWorkDataType(childS, 5,SS_INT8);

25078
          ssSetDWorkComplexSignal(childS, 5, 0);

25079
          _ssSetDWork(childS, 5, &((int8_T*) ssGetDWork(rts, 519))[0]);

25080


25081
          /* DWORK6 */

25082
          ssSetDWorkWidth(childS, 6, 1);

25083
          ssSetDWorkDataType(childS, 6,SS_INT8);

25084
          ssSetDWorkComplexSignal(childS, 6, 0);

25085
          _ssSetDWork(childS, 6, &((int8_T*) ssGetDWork(rts, 520))[0]);

25086
        }

25087


25088
        (childS)->regDataType.arg1 = ((void *)(childS));

25089
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

25090
          FcnSetErrorStatus);

25091
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

25092
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

25093
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

25094
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

25095


25096
        /* registration */

25097
#if defined(MATLAB_MEX_FILE)

25098


25099
        {

25100
          int_T i;

25101
          mxArray *plhs[1];

25102
          mxArray *prhs[4];

25103
          double *pr;

25104
          volatile int_T *intS = (int_T *)&childS;

25105
          int_T addrlen = sizeof(SimStruct *);

25106
          int_T m = addrlen/sizeof(int_T) + 1;

25107
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

25108
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

25109
          pr = mxGetPr(prhs[1]);

25110
          for (i = 0; i < m - 1; i++) {

25111
            pr[i] = (double)intS[i];

25112
          }

25113


25114
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

25115
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

25116
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

25117


25118
          /* Reset port dimensions info functions because the S-function

25119
           * and accelerator mex-files explicitly set their dimensions,

25120
           * i.e., they are not dynamically sized. For this case, the

25121
           * mex-file is responsible for the dimensions info memory

25122
           * and Simulink should not free it. This is achieved by

25123
           * setting the following two methods to NULL.

25124
           */

25125
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

25126
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

25127


25128
          /*

25129
           * Setup function pointers and call mdlInitializeSizes via

25130
           * simulink.c

25131
           */

25132
          mexCallMATLAB(1, plhs, 4, prhs, "Fader_sf");

25133
          mxDestroyArray(plhs[0]);

25134
          mxDestroyArray(prhs[0]);

25135
          mxDestroyArray(prhs[1]);

25136
          mxDestroyArray(prhs[2]);

25137
          mxDestroyArray(prhs[3]);

25138
        }

25139


25140
#else

25141


25142
        {

25143
          Fader_sf(childS);

25144
          sfcnInitializeSizes(childS);

25145
        }

25146


25147
#endif

25148


25149
        sfcnInitializeSampleTimes(childS);

25150


25151
        /* adjust sample time */

25152
        ssSetSampleTime(childS, 0, 0.0);

25153
        ssSetOffsetTime(childS, 0, 0.0);

25154
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

25155


25156
        /* set compiled values of dynamic vector attributes */

25157
        ssSetNumNonsampledZCs(childS, 0);

25158


25159
        /* Update connectivity flags for each port */

25160
        _ssSetInputPortConnected(childS, 0, 1);

25161
        _ssSetInputPortConnected(childS, 1, 1);

25162
        _ssSetInputPortConnected(childS, 2, 1);

25163
        _ssSetInputPortConnected(childS, 3, 1);

25164
        _ssSetInputPortConnected(childS, 4, 1);

25165
        _ssSetInputPortConnected(childS, 5, 1);

25166
        _ssSetOutputPortConnected(childS, 0, 1);

25167
        _ssSetOutputPortBeingMerged(childS, 0, 0);

25168


25169
        /* Update the BufferDstPort flags for each input port */

25170
        _ssSetInputPortBufferDstPort(childS, 0, -1);

25171
        _ssSetInputPortBufferDstPort(childS, 1, -1);

25172
        _ssSetInputPortBufferDstPort(childS, 2, -1);

25173
        _ssSetInputPortBufferDstPort(childS, 3, -1);

25174
        _ssSetInputPortBufferDstPort(childS, 4, -1);

25175
        _ssSetInputPortBufferDstPort(childS, 5, -1);

25176
      }

25177


25178
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S163>/Generated S-Function1 (SaturationLimiter_sf) */

25179
      {

25180
        SimStruct *childS = ssGetSFunction(rts, 95);

25181


25182
        /* timing info */

25183
        time_T *sfcnPeriod;

25184
        time_T *sfcnOffset;

25185
        int_T *sfcnTsMap;

25186
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

25187
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

25188
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

25189
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

25190
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

25191
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

25192
        (void) memset((void*)sfcnPeriod, 0,

25193
                      sizeof(time_T)*1);

25194
        (void) memset((void*)sfcnOffset, 0,

25195
                      sizeof(time_T)*1);

25196
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

25197
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

25198
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

25199


25200
        /* Set up the mdlInfo pointer */

25201
# ifdef USE_RTMODEL

25202


25203
        {

25204
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

25205
              struct _ssBlkInfo2));

25206
          ss_VALIDATE_MEMORY(rts,blkInfo2);

25207
          ssSetBlkInfo2Ptr(childS, blkInfo2);

25208
        }

25209


25210
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

25211


25212
# else

25213


25214
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

25215


25216
# endif                                /* USE_RTMODEL */

25217


25218
        /* Allocate memory of model methods 2 */

25219
        {

25220
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

25221
            malloc(sizeof(struct _ssSFcnModelMethods2));

25222
          ss_VALIDATE_MEMORY(rts,methods2);

25223
          ssSetModelMethods2(childS, methods2);

25224
        }

25225


25226
        /* Allocate memory of model methods 3 */

25227
        {

25228
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

25229
            malloc(sizeof(struct _ssSFcnModelMethods3));

25230
          ss_VALIDATE_MEMORY(rts,methods3);

25231
          ssSetModelMethods3(childS, methods3);

25232
        }

25233


25234
        /* Allocate memory for states auxilliary information */

25235
        {

25236
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

25237
            (sizeof(struct _ssStatesInfo2));

25238
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

25239
            malloc(sizeof(ssPeriodicStatesInfo));

25240
          ss_VALIDATE_MEMORY(rts,statesInfo2);

25241
          ssSetStatesInfo2(childS, statesInfo2);

25242
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

25243
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

25244
        }

25245


25246
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

25247
          RegNumInputPorts);

25248
        ssSetRegNumInputPortsFcnArg(childS,childS);

25249


25250
        /* inputs */

25251
        {

25252
          struct _ssPortInputs *inputPortInfo =

25253
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

25254
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

25255
          _ssSetNumInputPorts(childS, 3);

25256
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

25257


25258
          /* port 0 */

25259
          {

25260
            real32_T const **sfcnUPtrs = (real32_T const **)

25261
              malloc(1 * sizeof(real32_T *));

25262
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25263
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

25264
              ssGetLocalBlockIO(rts))->Divide_c2;

25265
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

25266
            _ssSetInputPortNumDimensions(childS, 0, 1);

25267
            ssSetInputPortWidth(childS, 0, 1);

25268
          }

25269


25270
          /* port 1 */

25271
          {

25272
            real32_T const **sfcnUPtrs = (real32_T const **)

25273
              malloc(1 * sizeof(real32_T *));

25274
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25275
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

25276
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

25277
            _ssSetInputPortNumDimensions(childS, 1, 1);

25278
            ssSetInputPortWidth(childS, 1, 1);

25279
          }

25280


25281
          /* port 2 */

25282
          {

25283
            real32_T const **sfcnUPtrs = (real32_T const **)

25284
              malloc(1 * sizeof(real32_T *));

25285
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25286
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

25287
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

25288
            _ssSetInputPortNumDimensions(childS, 2, 1);

25289
            ssSetInputPortWidth(childS, 2, 1);

25290
          }

25291
        }

25292


25293
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

25294
          RegNumOutputPorts);

25295
        ssSetRegNumOutputPortsFcnArg(childS,childS);

25296


25297
        /* outputs */

25298
        {

25299
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

25300
            calloc(1, sizeof(struct _ssPortOutputs));

25301
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

25302
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

25303
          _ssSetNumOutputPorts(childS, 1);

25304


25305
          /* port 0 */

25306
          {

25307
            _ssSetOutputPortNumDimensions(childS, 0, 1);

25308
            ssSetOutputPortWidth(childS, 0, 1);

25309
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

25310
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_nk));

25311
          }

25312
        }

25313


25314
        /* path info */

25315
        _ssSetModelName(childS, "SaturationLimiter_sf");

25316
        _ssSetPath(childS,

25317
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter2/Generated S-Function1");

25318
        if (ssGetRTModel(rts) == (NULL)) {

25319
          _ssSetParentSS(childS, rts);

25320
          _ssSetRootSS(childS, ssGetRootSS(rts));

25321
        } else {

25322
          ssSetRTModel(childS,ssGetRTModel(rts));

25323
          _ssSetParentSS(childS, (NULL));

25324
          _ssSetRootSS(childS, childS);

25325
        }

25326


25327
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

25328
        (childS)->regDataType.arg1 = ((void *)(childS));

25329
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

25330
          FcnSetErrorStatus);

25331
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

25332
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

25333
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

25334
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

25335


25336
        /* registration */

25337
#if defined(MATLAB_MEX_FILE)

25338


25339
        {

25340
          int_T i;

25341
          mxArray *plhs[1];

25342
          mxArray *prhs[4];

25343
          double *pr;

25344
          volatile int_T *intS = (int_T *)&childS;

25345
          int_T addrlen = sizeof(SimStruct *);

25346
          int_T m = addrlen/sizeof(int_T) + 1;

25347
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

25348
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

25349
          pr = mxGetPr(prhs[1]);

25350
          for (i = 0; i < m - 1; i++) {

25351
            pr[i] = (double)intS[i];

25352
          }

25353


25354
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

25355
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

25356
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

25357


25358
          /* Reset port dimensions info functions because the S-function

25359
           * and accelerator mex-files explicitly set their dimensions,

25360
           * i.e., they are not dynamically sized. For this case, the

25361
           * mex-file is responsible for the dimensions info memory

25362
           * and Simulink should not free it. This is achieved by

25363
           * setting the following two methods to NULL.

25364
           */

25365
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

25366
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

25367


25368
          /*

25369
           * Setup function pointers and call mdlInitializeSizes via

25370
           * simulink.c

25371
           */

25372
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

25373
          mxDestroyArray(plhs[0]);

25374
          mxDestroyArray(prhs[0]);

25375
          mxDestroyArray(prhs[1]);

25376
          mxDestroyArray(prhs[2]);

25377
          mxDestroyArray(prhs[3]);

25378
        }

25379


25380
#else

25381


25382
        {

25383
          SaturationLimiter_sf(childS);

25384
          sfcnInitializeSizes(childS);

25385
        }

25386


25387
#endif

25388


25389
        sfcnInitializeSampleTimes(childS);

25390


25391
        /* adjust sample time */

25392
        ssSetSampleTime(childS, 0, 0.005);

25393
        ssSetOffsetTime(childS, 0, 0.0);

25394
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];

25395


25396
        /* set compiled values of dynamic vector attributes */

25397
        ssSetNumNonsampledZCs(childS, 0);

25398


25399
        /* Update connectivity flags for each port */

25400
        _ssSetInputPortConnected(childS, 0, 1);

25401
        _ssSetInputPortConnected(childS, 1, 1);

25402
        _ssSetInputPortConnected(childS, 2, 1);

25403
        _ssSetOutputPortConnected(childS, 0, 1);

25404
        _ssSetOutputPortBeingMerged(childS, 0, 0);

25405


25406
        /* Update the BufferDstPort flags for each input port */

25407
        _ssSetInputPortBufferDstPort(childS, 0, -1);

25408
        _ssSetInputPortBufferDstPort(childS, 1, -1);

25409
        _ssSetInputPortBufferDstPort(childS, 2, -1);

25410
      }

25411


25412
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S165>/Generated S-Function1 (SaturationLimiter_sf) */

25413
      {

25414
        SimStruct *childS = ssGetSFunction(rts, 96);

25415


25416
        /* timing info */

25417
        time_T *sfcnPeriod;

25418
        time_T *sfcnOffset;

25419
        int_T *sfcnTsMap;

25420
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

25421
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

25422
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

25423
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

25424
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

25425
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

25426
        (void) memset((void*)sfcnPeriod, 0,

25427
                      sizeof(time_T)*1);

25428
        (void) memset((void*)sfcnOffset, 0,

25429
                      sizeof(time_T)*1);

25430
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

25431
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

25432
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

25433


25434
        /* Set up the mdlInfo pointer */

25435
# ifdef USE_RTMODEL

25436


25437
        {

25438
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

25439
              struct _ssBlkInfo2));

25440
          ss_VALIDATE_MEMORY(rts,blkInfo2);

25441
          ssSetBlkInfo2Ptr(childS, blkInfo2);

25442
        }

25443


25444
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

25445


25446
# else

25447


25448
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

25449


25450
# endif                                /* USE_RTMODEL */

25451


25452
        /* Allocate memory of model methods 2 */

25453
        {

25454
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

25455
            malloc(sizeof(struct _ssSFcnModelMethods2));

25456
          ss_VALIDATE_MEMORY(rts,methods2);

25457
          ssSetModelMethods2(childS, methods2);

25458
        }

25459


25460
        /* Allocate memory of model methods 3 */

25461
        {

25462
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

25463
            malloc(sizeof(struct _ssSFcnModelMethods3));

25464
          ss_VALIDATE_MEMORY(rts,methods3);

25465
          ssSetModelMethods3(childS, methods3);

25466
        }

25467


25468
        /* Allocate memory for states auxilliary information */

25469
        {

25470
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

25471
            (sizeof(struct _ssStatesInfo2));

25472
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

25473
            malloc(sizeof(ssPeriodicStatesInfo));

25474
          ss_VALIDATE_MEMORY(rts,statesInfo2);

25475
          ssSetStatesInfo2(childS, statesInfo2);

25476
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

25477
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

25478
        }

25479


25480
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

25481
          RegNumInputPorts);

25482
        ssSetRegNumInputPortsFcnArg(childS,childS);

25483


25484
        /* inputs */

25485
        {

25486
          struct _ssPortInputs *inputPortInfo =

25487
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

25488
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

25489
          _ssSetNumInputPorts(childS, 3);

25490
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

25491


25492
          /* port 0 */

25493
          {

25494
            real32_T const **sfcnUPtrs = (real32_T const **)

25495
              malloc(1 * sizeof(real32_T *));

25496
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25497
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

25498
              ssGetLocalBlockIO(rts))->Divide1_d;

25499
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

25500
            _ssSetInputPortNumDimensions(childS, 0, 1);

25501
            ssSetInputPortWidth(childS, 0, 1);

25502
          }

25503


25504
          /* port 1 */

25505
          {

25506
            real32_T const **sfcnUPtrs = (real32_T const **)

25507
              malloc(1 * sizeof(real32_T *));

25508
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25509
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

25510
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

25511
            _ssSetInputPortNumDimensions(childS, 1, 1);

25512
            ssSetInputPortWidth(childS, 1, 1);

25513
          }

25514


25515
          /* port 2 */

25516
          {

25517
            real32_T const **sfcnUPtrs = (real32_T const **)

25518
              malloc(1 * sizeof(real32_T *));

25519
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25520
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;

25521
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

25522
            _ssSetInputPortNumDimensions(childS, 2, 1);

25523
            ssSetInputPortWidth(childS, 2, 1);

25524
          }

25525
        }

25526


25527
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

25528
          RegNumOutputPorts);

25529
        ssSetRegNumOutputPortsFcnArg(childS,childS);

25530


25531
        /* outputs */

25532
        {

25533
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

25534
            calloc(1, sizeof(struct _ssPortOutputs));

25535
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

25536
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

25537
          _ssSetNumOutputPorts(childS, 1);

25538


25539
          /* port 0 */

25540
          {

25541
            _ssSetOutputPortNumDimensions(childS, 0, 1);

25542
            ssSetOutputPortWidth(childS, 0, 1);

25543
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

25544
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_d));

25545
          }

25546
        }

25547


25548
        /* path info */

25549
        _ssSetModelName(childS, "SaturationLimiter_sf");

25550
        _ssSetPath(childS,

25551
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter4/Generated S-Function1");

25552
        if (ssGetRTModel(rts) == (NULL)) {

25553
          _ssSetParentSS(childS, rts);

25554
          _ssSetRootSS(childS, ssGetRootSS(rts));

25555
        } else {

25556
          ssSetRTModel(childS,ssGetRTModel(rts));

25557
          _ssSetParentSS(childS, (NULL));

25558
          _ssSetRootSS(childS, childS);

25559
        }

25560


25561
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

25562
        (childS)->regDataType.arg1 = ((void *)(childS));

25563
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

25564
          FcnSetErrorStatus);

25565
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

25566
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

25567
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

25568
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

25569


25570
        /* registration */

25571
#if defined(MATLAB_MEX_FILE)

25572


25573
        {

25574
          int_T i;

25575
          mxArray *plhs[1];

25576
          mxArray *prhs[4];

25577
          double *pr;

25578
          volatile int_T *intS = (int_T *)&childS;

25579
          int_T addrlen = sizeof(SimStruct *);

25580
          int_T m = addrlen/sizeof(int_T) + 1;

25581
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

25582
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

25583
          pr = mxGetPr(prhs[1]);

25584
          for (i = 0; i < m - 1; i++) {

25585
            pr[i] = (double)intS[i];

25586
          }

25587


25588
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

25589
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

25590
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

25591


25592
          /* Reset port dimensions info functions because the S-function

25593
           * and accelerator mex-files explicitly set their dimensions,

25594
           * i.e., they are not dynamically sized. For this case, the

25595
           * mex-file is responsible for the dimensions info memory

25596
           * and Simulink should not free it. This is achieved by

25597
           * setting the following two methods to NULL.

25598
           */

25599
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

25600
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

25601


25602
          /*

25603
           * Setup function pointers and call mdlInitializeSizes via

25604
           * simulink.c

25605
           */

25606
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

25607
          mxDestroyArray(plhs[0]);

25608
          mxDestroyArray(prhs[0]);

25609
          mxDestroyArray(prhs[1]);

25610
          mxDestroyArray(prhs[2]);

25611
          mxDestroyArray(prhs[3]);

25612
        }

25613


25614
#else

25615


25616
        {

25617
          SaturationLimiter_sf(childS);

25618
          sfcnInitializeSizes(childS);

25619
        }

25620


25621
#endif

25622


25623
        sfcnInitializeSampleTimes(childS);

25624


25625
        /* adjust sample time */

25626
        ssSetSampleTime(childS, 0, 0.0);

25627
        ssSetOffsetTime(childS, 0, 0.0);

25628
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

25629


25630
        /* set compiled values of dynamic vector attributes */

25631
        ssSetNumNonsampledZCs(childS, 0);

25632


25633
        /* Update connectivity flags for each port */

25634
        _ssSetInputPortConnected(childS, 0, 1);

25635
        _ssSetInputPortConnected(childS, 1, 1);

25636
        _ssSetInputPortConnected(childS, 2, 1);

25637
        _ssSetOutputPortConnected(childS, 0, 1);

25638
        _ssSetOutputPortBeingMerged(childS, 0, 0);

25639


25640
        /* Update the BufferDstPort flags for each input port */

25641
        _ssSetInputPortBufferDstPort(childS, 0, -1);

25642
        _ssSetInputPortBufferDstPort(childS, 1, -1);

25643
        _ssSetInputPortBufferDstPort(childS, 2, -1);

25644
      }

25645


25646
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S190>/Generated S-Function4 (LagFilter_sf) */

25647
      {

25648
        SimStruct *childS = ssGetSFunction(rts, 97);

25649


25650
        /* timing info */

25651
        time_T *sfcnPeriod;

25652
        time_T *sfcnOffset;

25653
        int_T *sfcnTsMap;

25654
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

25655
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

25656
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

25657
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

25658
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

25659
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

25660
        (void) memset((void*)sfcnPeriod, 0,

25661
                      sizeof(time_T)*1);

25662
        (void) memset((void*)sfcnOffset, 0,

25663
                      sizeof(time_T)*1);

25664
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

25665
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

25666
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

25667


25668
        /* Set up the mdlInfo pointer */

25669
# ifdef USE_RTMODEL

25670


25671
        {

25672
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

25673
              struct _ssBlkInfo2));

25674
          ss_VALIDATE_MEMORY(rts,blkInfo2);

25675
          ssSetBlkInfo2Ptr(childS, blkInfo2);

25676
        }

25677


25678
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

25679


25680
# else

25681


25682
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

25683


25684
# endif                                /* USE_RTMODEL */

25685


25686
        /* Allocate memory of model methods 2 */

25687
        {

25688
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

25689
            malloc(sizeof(struct _ssSFcnModelMethods2));

25690
          ss_VALIDATE_MEMORY(rts,methods2);

25691
          ssSetModelMethods2(childS, methods2);

25692
        }

25693


25694
        /* Allocate memory of model methods 3 */

25695
        {

25696
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

25697
            malloc(sizeof(struct _ssSFcnModelMethods3));

25698
          ss_VALIDATE_MEMORY(rts,methods3);

25699
          ssSetModelMethods3(childS, methods3);

25700
        }

25701


25702
        /* Allocate memory for states auxilliary information */

25703
        {

25704
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

25705
            (sizeof(struct _ssStatesInfo2));

25706
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

25707
            malloc(sizeof(ssPeriodicStatesInfo));

25708
          ss_VALIDATE_MEMORY(rts,statesInfo2);

25709
          ssSetStatesInfo2(childS, statesInfo2);

25710
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

25711
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

25712
        }

25713


25714
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

25715
          RegNumInputPorts);

25716
        ssSetRegNumInputPortsFcnArg(childS,childS);

25717


25718
        /* inputs */

25719
        {

25720
          struct _ssPortInputs *inputPortInfo =

25721
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

25722
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

25723
          _ssSetNumInputPorts(childS, 6);

25724
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

25725


25726
          /* port 0 */

25727
          {

25728
            real32_T const **sfcnUPtrs = (real32_T const **)

25729
              malloc(1 * sizeof(real32_T *));

25730
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25731
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

25732
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

25733
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

25734
            _ssSetInputPortNumDimensions(childS, 0, 1);

25735
            ssSetInputPortWidth(childS, 0, 1);

25736
          }

25737


25738
          /* port 1 */

25739
          {

25740
            int8_T const **sfcnUPtrs = (int8_T const **)

25741
              malloc(1 * sizeof(int8_T *));

25742
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25743
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

25744
              ssGetLocalBlockIO(rts))->DataTypeConversion_f;

25745
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

25746
            _ssSetInputPortNumDimensions(childS, 1, 1);

25747
            ssSetInputPortWidth(childS, 1, 1);

25748
          }

25749


25750
          /* port 2 */

25751
          {

25752
            real32_T const **sfcnUPtrs = (real32_T const **)

25753
              malloc(1 * sizeof(real32_T *));

25754
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25755
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;

25756
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

25757
            _ssSetInputPortNumDimensions(childS, 2, 1);

25758
            ssSetInputPortWidth(childS, 2, 1);

25759
          }

25760


25761
          /* port 3 */

25762
          {

25763
            real32_T const **sfcnUPtrs = (real32_T const **)

25764
              malloc(1 * sizeof(real32_T *));

25765
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25766
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

25767
              ssGetLocalBlockIO(rts))->Switch_jf;

25768
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

25769
            _ssSetInputPortNumDimensions(childS, 3, 1);

25770
            ssSetInputPortWidth(childS, 3, 1);

25771
          }

25772


25773
          /* port 4 */

25774
          {

25775
            real32_T const **sfcnUPtrs = (real32_T const **)

25776
              malloc(1 * sizeof(real32_T *));

25777
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25778
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

25779
              ssGetLocalBlockIO(rts))->Switch_jf;

25780
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

25781
            _ssSetInputPortNumDimensions(childS, 4, 1);

25782
            ssSetInputPortWidth(childS, 4, 1);

25783
          }

25784


25785
          /* port 5 */

25786
          {

25787
            real32_T const **sfcnUPtrs = (real32_T const **)

25788
              malloc(1 * sizeof(real32_T *));

25789
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

25790
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

25791
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

25792
            _ssSetInputPortNumDimensions(childS, 5, 1);

25793
            ssSetInputPortWidth(childS, 5, 1);

25794
          }

25795
        }

25796


25797
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

25798
          RegNumOutputPorts);

25799
        ssSetRegNumOutputPortsFcnArg(childS,childS);

25800


25801
        /* outputs */

25802
        {

25803
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

25804
            calloc(1, sizeof(struct _ssPortOutputs));

25805
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

25806
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

25807
          _ssSetNumOutputPorts(childS, 1);

25808


25809
          /* port 0 */

25810
          {

25811
            _ssSetOutputPortNumDimensions(childS, 0, 1);

25812
            ssSetOutputPortWidth(childS, 0, 1);

25813
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

25814
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_k));

25815
          }

25816
        }

25817


25818
        /* path info */

25819
        _ssSetModelName(childS, "LagFilter_sf");

25820
        _ssSetPath(childS,

25821
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/ lag filter/Generated S-Function4");

25822
        if (ssGetRTModel(rts) == (NULL)) {

25823
          _ssSetParentSS(childS, rts);

25824
          _ssSetRootSS(childS, ssGetRootSS(rts));

25825
        } else {

25826
          ssSetRTModel(childS,ssGetRTModel(rts));

25827
          _ssSetParentSS(childS, (NULL));

25828
          _ssSetRootSS(childS, childS);

25829
        }

25830


25831
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

25832


25833
        /* work vectors */

25834
        {

25835
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

25836
            (4 * sizeof(struct _ssDWorkRecord));

25837
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

25838
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

25839
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

25840
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

25841
          ssSetSFcnDWork(childS, dWorkRecord);

25842
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

25843
          _ssSetNumDWork(childS, 4);

25844


25845
          /* DWORK0 */

25846
          ssSetDWorkWidth(childS, 0, 1);

25847
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

25848
          ssSetDWorkComplexSignal(childS, 0, 0);

25849
          ssSetDWorkUsedAsDState(childS, 0, 1);

25850
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 219))[0]);

25851


25852
          /* DWORK1 */

25853
          ssSetDWorkWidth(childS, 1, 1);

25854
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

25855
          ssSetDWorkComplexSignal(childS, 1, 0);

25856
          ssSetDWorkUsedAsDState(childS, 1, 1);

25857
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 220))[0]);

25858


25859
          /* DWORK2 */

25860
          ssSetDWorkWidth(childS, 2, 1);

25861
          ssSetDWorkDataType(childS, 2,SS_INT8);

25862
          ssSetDWorkComplexSignal(childS, 2, 0);

25863
          ssSetDWorkUsedAsDState(childS, 2, 1);

25864
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 446))[0]);

25865


25866
          /* DWORK3 */

25867
          ssSetDWorkWidth(childS, 3, 1);

25868
          ssSetDWorkDataType(childS, 3,SS_INT8);

25869
          ssSetDWorkComplexSignal(childS, 3, 0);

25870
          ssSetDWorkUsedAsDState(childS, 3, 1);

25871
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 447))[0]);

25872
        }

25873


25874
        (childS)->regDataType.arg1 = ((void *)(childS));

25875
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

25876
          FcnSetErrorStatus);

25877
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

25878
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

25879
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

25880
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

25881


25882
        /* registration */

25883
#if defined(MATLAB_MEX_FILE)

25884


25885
        {

25886
          int_T i;

25887
          mxArray *plhs[1];

25888
          mxArray *prhs[4];

25889
          double *pr;

25890
          volatile int_T *intS = (int_T *)&childS;

25891
          int_T addrlen = sizeof(SimStruct *);

25892
          int_T m = addrlen/sizeof(int_T) + 1;

25893
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

25894
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

25895
          pr = mxGetPr(prhs[1]);

25896
          for (i = 0; i < m - 1; i++) {

25897
            pr[i] = (double)intS[i];

25898
          }

25899


25900
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

25901
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

25902
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

25903


25904
          /* Reset port dimensions info functions because the S-function

25905
           * and accelerator mex-files explicitly set their dimensions,

25906
           * i.e., they are not dynamically sized. For this case, the

25907
           * mex-file is responsible for the dimensions info memory

25908
           * and Simulink should not free it. This is achieved by

25909
           * setting the following two methods to NULL.

25910
           */

25911
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

25912
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

25913


25914
          /*

25915
           * Setup function pointers and call mdlInitializeSizes via

25916
           * simulink.c

25917
           */

25918
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

25919
          mxDestroyArray(plhs[0]);

25920
          mxDestroyArray(prhs[0]);

25921
          mxDestroyArray(prhs[1]);

25922
          mxDestroyArray(prhs[2]);

25923
          mxDestroyArray(prhs[3]);

25924
        }

25925


25926
#else

25927


25928
        {

25929
          LagFilter_sf(childS);

25930
          sfcnInitializeSizes(childS);

25931
        }

25932


25933
#endif

25934


25935
        sfcnInitializeSampleTimes(childS);

25936


25937
        /* adjust sample time */

25938
        ssSetSampleTime(childS, 0, 0.0);

25939
        ssSetOffsetTime(childS, 0, 0.0);

25940
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

25941


25942
        /* set compiled values of dynamic vector attributes */

25943
        ssSetNumNonsampledZCs(childS, 0);

25944


25945
        /* Update connectivity flags for each port */

25946
        _ssSetInputPortConnected(childS, 0, 1);

25947
        _ssSetInputPortConnected(childS, 1, 1);

25948
        _ssSetInputPortConnected(childS, 2, 1);

25949
        _ssSetInputPortConnected(childS, 3, 1);

25950
        _ssSetInputPortConnected(childS, 4, 1);

25951
        _ssSetInputPortConnected(childS, 5, 1);

25952
        _ssSetOutputPortConnected(childS, 0, 1);

25953
        _ssSetOutputPortBeingMerged(childS, 0, 0);

25954


25955
        /* Update the BufferDstPort flags for each input port */

25956
        _ssSetInputPortBufferDstPort(childS, 0, -1);

25957
        _ssSetInputPortBufferDstPort(childS, 1, -1);

25958
        _ssSetInputPortBufferDstPort(childS, 2, -1);

25959
        _ssSetInputPortBufferDstPort(childS, 3, -1);

25960
        _ssSetInputPortBufferDstPort(childS, 4, -1);

25961
        _ssSetInputPortBufferDstPort(childS, 5, -1);

25962
      }

25963


25964
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S191>/Generated S-Function4 (LagFilter_sf) */

25965
      {

25966
        SimStruct *childS = ssGetSFunction(rts, 98);

25967


25968
        /* timing info */

25969
        time_T *sfcnPeriod;

25970
        time_T *sfcnOffset;

25971
        int_T *sfcnTsMap;

25972
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

25973
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

25974
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

25975
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

25976
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

25977
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

25978
        (void) memset((void*)sfcnPeriod, 0,

25979
                      sizeof(time_T)*1);

25980
        (void) memset((void*)sfcnOffset, 0,

25981
                      sizeof(time_T)*1);

25982
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

25983
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

25984
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

25985


25986
        /* Set up the mdlInfo pointer */

25987
# ifdef USE_RTMODEL

25988


25989
        {

25990
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

25991
              struct _ssBlkInfo2));

25992
          ss_VALIDATE_MEMORY(rts,blkInfo2);

25993
          ssSetBlkInfo2Ptr(childS, blkInfo2);

25994
        }

25995


25996
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

25997


25998
# else

25999


26000
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

26001


26002
# endif                                /* USE_RTMODEL */

26003


26004
        /* Allocate memory of model methods 2 */

26005
        {

26006
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

26007
            malloc(sizeof(struct _ssSFcnModelMethods2));

26008
          ss_VALIDATE_MEMORY(rts,methods2);

26009
          ssSetModelMethods2(childS, methods2);

26010
        }

26011


26012
        /* Allocate memory of model methods 3 */

26013
        {

26014
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

26015
            malloc(sizeof(struct _ssSFcnModelMethods3));

26016
          ss_VALIDATE_MEMORY(rts,methods3);

26017
          ssSetModelMethods3(childS, methods3);

26018
        }

26019


26020
        /* Allocate memory for states auxilliary information */

26021
        {

26022
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

26023
            (sizeof(struct _ssStatesInfo2));

26024
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

26025
            malloc(sizeof(ssPeriodicStatesInfo));

26026
          ss_VALIDATE_MEMORY(rts,statesInfo2);

26027
          ssSetStatesInfo2(childS, statesInfo2);

26028
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

26029
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

26030
        }

26031


26032
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

26033
          RegNumInputPorts);

26034
        ssSetRegNumInputPortsFcnArg(childS,childS);

26035


26036
        /* inputs */

26037
        {

26038
          struct _ssPortInputs *inputPortInfo =

26039
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

26040
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

26041
          _ssSetNumInputPorts(childS, 6);

26042
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

26043


26044
          /* port 0 */

26045
          {

26046
            real32_T const **sfcnUPtrs = (real32_T const **)

26047
              malloc(1 * sizeof(real32_T *));

26048
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26049
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

26050
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

26051
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

26052
            _ssSetInputPortNumDimensions(childS, 0, 1);

26053
            ssSetInputPortWidth(childS, 0, 1);

26054
          }

26055


26056
          /* port 1 */

26057
          {

26058
            int8_T const **sfcnUPtrs = (int8_T const **)

26059
              malloc(1 * sizeof(int8_T *));

26060
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26061
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

26062
              ssGetLocalBlockIO(rts))->DataTypeConversion3_l;

26063
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

26064
            _ssSetInputPortNumDimensions(childS, 1, 1);

26065
            ssSetInputPortWidth(childS, 1, 1);

26066
          }

26067


26068
          /* port 2 */

26069
          {

26070
            real32_T const **sfcnUPtrs = (real32_T const **)

26071
              malloc(1 * sizeof(real32_T *));

26072
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26073
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;

26074
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

26075
            _ssSetInputPortNumDimensions(childS, 2, 1);

26076
            ssSetInputPortWidth(childS, 2, 1);

26077
          }

26078


26079
          /* port 3 */

26080
          {

26081
            real32_T const **sfcnUPtrs = (real32_T const **)

26082
              malloc(1 * sizeof(real32_T *));

26083
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26084
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

26085
              ssGetLocalBlockIO(rts))->Switch_jf;

26086
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

26087
            _ssSetInputPortNumDimensions(childS, 3, 1);

26088
            ssSetInputPortWidth(childS, 3, 1);

26089
          }

26090


26091
          /* port 4 */

26092
          {

26093
            real32_T const **sfcnUPtrs = (real32_T const **)

26094
              malloc(1 * sizeof(real32_T *));

26095
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26096
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

26097
              ssGetLocalBlockIO(rts))->Switch_jf;

26098
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

26099
            _ssSetInputPortNumDimensions(childS, 4, 1);

26100
            ssSetInputPortWidth(childS, 4, 1);

26101
          }

26102


26103
          /* port 5 */

26104
          {

26105
            real32_T const **sfcnUPtrs = (real32_T const **)

26106
              malloc(1 * sizeof(real32_T *));

26107
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26108
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

26109
              ssGetLocalBlockIO(rts))->Switch7;

26110
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

26111
            _ssSetInputPortNumDimensions(childS, 5, 1);

26112
            ssSetInputPortWidth(childS, 5, 1);

26113
          }

26114
        }

26115


26116
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

26117
          RegNumOutputPorts);

26118
        ssSetRegNumOutputPortsFcnArg(childS,childS);

26119


26120
        /* outputs */

26121
        {

26122
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

26123
            calloc(1, sizeof(struct _ssPortOutputs));

26124
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

26125
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

26126
          _ssSetNumOutputPorts(childS, 1);

26127


26128
          /* port 0 */

26129
          {

26130
            _ssSetOutputPortNumDimensions(childS, 0, 1);

26131
            ssSetOutputPortWidth(childS, 0, 1);

26132
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

26133
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_p));

26134
          }

26135
        }

26136


26137
        /* path info */

26138
        _ssSetModelName(childS, "LagFilter_sf");

26139
        _ssSetPath(childS,

26140
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/ lag filter1/Generated S-Function4");

26141
        if (ssGetRTModel(rts) == (NULL)) {

26142
          _ssSetParentSS(childS, rts);

26143
          _ssSetRootSS(childS, ssGetRootSS(rts));

26144
        } else {

26145
          ssSetRTModel(childS,ssGetRTModel(rts));

26146
          _ssSetParentSS(childS, (NULL));

26147
          _ssSetRootSS(childS, childS);

26148
        }

26149


26150
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

26151


26152
        /* work vectors */

26153
        {

26154
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

26155
            (4 * sizeof(struct _ssDWorkRecord));

26156
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

26157
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

26158
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

26159
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

26160
          ssSetSFcnDWork(childS, dWorkRecord);

26161
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

26162
          _ssSetNumDWork(childS, 4);

26163


26164
          /* DWORK0 */

26165
          ssSetDWorkWidth(childS, 0, 1);

26166
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

26167
          ssSetDWorkComplexSignal(childS, 0, 0);

26168
          ssSetDWorkUsedAsDState(childS, 0, 1);

26169
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 221))[0]);

26170


26171
          /* DWORK1 */

26172
          ssSetDWorkWidth(childS, 1, 1);

26173
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

26174
          ssSetDWorkComplexSignal(childS, 1, 0);

26175
          ssSetDWorkUsedAsDState(childS, 1, 1);

26176
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 222))[0]);

26177


26178
          /* DWORK2 */

26179
          ssSetDWorkWidth(childS, 2, 1);

26180
          ssSetDWorkDataType(childS, 2,SS_INT8);

26181
          ssSetDWorkComplexSignal(childS, 2, 0);

26182
          ssSetDWorkUsedAsDState(childS, 2, 1);

26183
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 448))[0]);

26184


26185
          /* DWORK3 */

26186
          ssSetDWorkWidth(childS, 3, 1);

26187
          ssSetDWorkDataType(childS, 3,SS_INT8);

26188
          ssSetDWorkComplexSignal(childS, 3, 0);

26189
          ssSetDWorkUsedAsDState(childS, 3, 1);

26190
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 449))[0]);

26191
        }

26192


26193
        (childS)->regDataType.arg1 = ((void *)(childS));

26194
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

26195
          FcnSetErrorStatus);

26196
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

26197
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

26198
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

26199
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

26200


26201
        /* registration */

26202
#if defined(MATLAB_MEX_FILE)

26203


26204
        {

26205
          int_T i;

26206
          mxArray *plhs[1];

26207
          mxArray *prhs[4];

26208
          double *pr;

26209
          volatile int_T *intS = (int_T *)&childS;

26210
          int_T addrlen = sizeof(SimStruct *);

26211
          int_T m = addrlen/sizeof(int_T) + 1;

26212
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

26213
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

26214
          pr = mxGetPr(prhs[1]);

26215
          for (i = 0; i < m - 1; i++) {

26216
            pr[i] = (double)intS[i];

26217
          }

26218


26219
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

26220
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

26221
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

26222


26223
          /* Reset port dimensions info functions because the S-function

26224
           * and accelerator mex-files explicitly set their dimensions,

26225
           * i.e., they are not dynamically sized. For this case, the

26226
           * mex-file is responsible for the dimensions info memory

26227
           * and Simulink should not free it. This is achieved by

26228
           * setting the following two methods to NULL.

26229
           */

26230
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

26231
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

26232


26233
          /*

26234
           * Setup function pointers and call mdlInitializeSizes via

26235
           * simulink.c

26236
           */

26237
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

26238
          mxDestroyArray(plhs[0]);

26239
          mxDestroyArray(prhs[0]);

26240
          mxDestroyArray(prhs[1]);

26241
          mxDestroyArray(prhs[2]);

26242
          mxDestroyArray(prhs[3]);

26243
        }

26244


26245
#else

26246


26247
        {

26248
          LagFilter_sf(childS);

26249
          sfcnInitializeSizes(childS);

26250
        }

26251


26252
#endif

26253


26254
        sfcnInitializeSampleTimes(childS);

26255


26256
        /* adjust sample time */

26257
        ssSetSampleTime(childS, 0, 0.0);

26258
        ssSetOffsetTime(childS, 0, 0.0);

26259
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

26260


26261
        /* set compiled values of dynamic vector attributes */

26262
        ssSetNumNonsampledZCs(childS, 0);

26263


26264
        /* Update connectivity flags for each port */

26265
        _ssSetInputPortConnected(childS, 0, 1);

26266
        _ssSetInputPortConnected(childS, 1, 1);

26267
        _ssSetInputPortConnected(childS, 2, 1);

26268
        _ssSetInputPortConnected(childS, 3, 1);

26269
        _ssSetInputPortConnected(childS, 4, 1);

26270
        _ssSetInputPortConnected(childS, 5, 1);

26271
        _ssSetOutputPortConnected(childS, 0, 1);

26272
        _ssSetOutputPortBeingMerged(childS, 0, 0);

26273


26274
        /* Update the BufferDstPort flags for each input port */

26275
        _ssSetInputPortBufferDstPort(childS, 0, -1);

26276
        _ssSetInputPortBufferDstPort(childS, 1, -1);

26277
        _ssSetInputPortBufferDstPort(childS, 2, -1);

26278
        _ssSetInputPortBufferDstPort(childS, 3, -1);

26279
        _ssSetInputPortBufferDstPort(childS, 4, -1);

26280
        _ssSetInputPortBufferDstPort(childS, 5, -1);

26281
      }

26282


26283
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S193>/Generated S-Function (Res180_sf) */

26284
      {

26285
        SimStruct *childS = ssGetSFunction(rts, 99);

26286


26287
        /* timing info */

26288
        time_T *sfcnPeriod;

26289
        time_T *sfcnOffset;

26290
        int_T *sfcnTsMap;

26291
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

26292
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

26293
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

26294
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

26295
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

26296
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

26297
        (void) memset((void*)sfcnPeriod, 0,

26298
                      sizeof(time_T)*1);

26299
        (void) memset((void*)sfcnOffset, 0,

26300
                      sizeof(time_T)*1);

26301
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

26302
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

26303
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

26304


26305
        /* Set up the mdlInfo pointer */

26306
# ifdef USE_RTMODEL

26307


26308
        {

26309
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

26310
              struct _ssBlkInfo2));

26311
          ss_VALIDATE_MEMORY(rts,blkInfo2);

26312
          ssSetBlkInfo2Ptr(childS, blkInfo2);

26313
        }

26314


26315
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

26316


26317
# else

26318


26319
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

26320


26321
# endif                                /* USE_RTMODEL */

26322


26323
        /* Allocate memory of model methods 2 */

26324
        {

26325
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

26326
            malloc(sizeof(struct _ssSFcnModelMethods2));

26327
          ss_VALIDATE_MEMORY(rts,methods2);

26328
          ssSetModelMethods2(childS, methods2);

26329
        }

26330


26331
        /* Allocate memory of model methods 3 */

26332
        {

26333
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

26334
            malloc(sizeof(struct _ssSFcnModelMethods3));

26335
          ss_VALIDATE_MEMORY(rts,methods3);

26336
          ssSetModelMethods3(childS, methods3);

26337
        }

26338


26339
        /* Allocate memory for states auxilliary information */

26340
        {

26341
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

26342
            (sizeof(struct _ssStatesInfo2));

26343
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

26344
            malloc(sizeof(ssPeriodicStatesInfo));

26345
          ss_VALIDATE_MEMORY(rts,statesInfo2);

26346
          ssSetStatesInfo2(childS, statesInfo2);

26347
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

26348
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

26349
        }

26350


26351
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

26352
          RegNumInputPorts);

26353
        ssSetRegNumInputPortsFcnArg(childS,childS);

26354


26355
        /* inputs */

26356
        {

26357
          struct _ssPortInputs *inputPortInfo =

26358
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

26359
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

26360
          _ssSetNumInputPorts(childS, 1);

26361
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

26362


26363
          /* port 0 */

26364
          {

26365
            real32_T const **sfcnUPtrs = (real32_T const **)

26366
              malloc(1 * sizeof(real32_T *));

26367
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26368
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

26369
              ssGetLocalBlockIO(rts))->Sum3_g5;

26370
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

26371
            _ssSetInputPortNumDimensions(childS, 0, 1);

26372
            ssSetInputPortWidth(childS, 0, 1);

26373
          }

26374
        }

26375


26376
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

26377
          RegNumOutputPorts);

26378
        ssSetRegNumOutputPortsFcnArg(childS,childS);

26379


26380
        /* outputs */

26381
        {

26382
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

26383
            calloc(1, sizeof(struct _ssPortOutputs));

26384
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

26385
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

26386
          _ssSetNumOutputPorts(childS, 1);

26387


26388
          /* port 0 */

26389
          {

26390
            _ssSetOutputPortNumDimensions(childS, 0, 1);

26391
            ssSetOutputPortWidth(childS, 0, 1);

26392
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

26393
              ssGetLocalBlockIO(rts))->GeneratedSFunction_bb));

26394
          }

26395
        }

26396


26397
        /* path info */

26398
        _ssSetModelName(childS, "Res180_sf");

26399
        _ssSetPath(childS,

26400
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/Generated S-Function");

26401
        if (ssGetRTModel(rts) == (NULL)) {

26402
          _ssSetParentSS(childS, rts);

26403
          _ssSetRootSS(childS, ssGetRootSS(rts));

26404
        } else {

26405
          ssSetRTModel(childS,ssGetRTModel(rts));

26406
          _ssSetParentSS(childS, (NULL));

26407
          _ssSetRootSS(childS, childS);

26408
        }

26409


26410
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

26411
        (childS)->regDataType.arg1 = ((void *)(childS));

26412
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

26413
          FcnSetErrorStatus);

26414
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

26415
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

26416
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

26417
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

26418


26419
        /* registration */

26420
#if defined(MATLAB_MEX_FILE)

26421


26422
        {

26423
          int_T i;

26424
          mxArray *plhs[1];

26425
          mxArray *prhs[4];

26426
          double *pr;

26427
          volatile int_T *intS = (int_T *)&childS;

26428
          int_T addrlen = sizeof(SimStruct *);

26429
          int_T m = addrlen/sizeof(int_T) + 1;

26430
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

26431
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

26432
          pr = mxGetPr(prhs[1]);

26433
          for (i = 0; i < m - 1; i++) {

26434
            pr[i] = (double)intS[i];

26435
          }

26436


26437
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

26438
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

26439
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

26440


26441
          /* Reset port dimensions info functions because the S-function

26442
           * and accelerator mex-files explicitly set their dimensions,

26443
           * i.e., they are not dynamically sized. For this case, the

26444
           * mex-file is responsible for the dimensions info memory

26445
           * and Simulink should not free it. This is achieved by

26446
           * setting the following two methods to NULL.

26447
           */

26448
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

26449
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

26450


26451
          /*

26452
           * Setup function pointers and call mdlInitializeSizes via

26453
           * simulink.c

26454
           */

26455
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

26456
          mxDestroyArray(plhs[0]);

26457
          mxDestroyArray(prhs[0]);

26458
          mxDestroyArray(prhs[1]);

26459
          mxDestroyArray(prhs[2]);

26460
          mxDestroyArray(prhs[3]);

26461
        }

26462


26463
#else

26464


26465
        {

26466
          Res180_sf(childS);

26467
          sfcnInitializeSizes(childS);

26468
        }

26469


26470
#endif

26471


26472
        sfcnInitializeSampleTimes(childS);

26473


26474
        /* adjust sample time */

26475
        ssSetSampleTime(childS, 0, 0.0);

26476
        ssSetOffsetTime(childS, 0, 0.0);

26477
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

26478


26479
        /* set compiled values of dynamic vector attributes */

26480
        ssSetNumNonsampledZCs(childS, 0);

26481


26482
        /* Update connectivity flags for each port */

26483
        _ssSetInputPortConnected(childS, 0, 1);

26484
        _ssSetOutputPortConnected(childS, 0, 1);

26485
        _ssSetOutputPortBeingMerged(childS, 0, 0);

26486


26487
        /* Update the BufferDstPort flags for each input port */

26488
        _ssSetInputPortBufferDstPort(childS, 0, -1);

26489
      }

26490


26491
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S198>/Generated S-Function1 (SaturationLimiter_sf) */

26492
      {

26493
        SimStruct *childS = ssGetSFunction(rts, 100);

26494


26495
        /* timing info */

26496
        time_T *sfcnPeriod;

26497
        time_T *sfcnOffset;

26498
        int_T *sfcnTsMap;

26499
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

26500
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

26501
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

26502
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

26503
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

26504
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

26505
        (void) memset((void*)sfcnPeriod, 0,

26506
                      sizeof(time_T)*1);

26507
        (void) memset((void*)sfcnOffset, 0,

26508
                      sizeof(time_T)*1);

26509
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

26510
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

26511
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

26512


26513
        /* Set up the mdlInfo pointer */

26514
# ifdef USE_RTMODEL

26515


26516
        {

26517
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

26518
              struct _ssBlkInfo2));

26519
          ss_VALIDATE_MEMORY(rts,blkInfo2);

26520
          ssSetBlkInfo2Ptr(childS, blkInfo2);

26521
        }

26522


26523
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

26524


26525
# else

26526


26527
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

26528


26529
# endif                                /* USE_RTMODEL */

26530


26531
        /* Allocate memory of model methods 2 */

26532
        {

26533
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

26534
            malloc(sizeof(struct _ssSFcnModelMethods2));

26535
          ss_VALIDATE_MEMORY(rts,methods2);

26536
          ssSetModelMethods2(childS, methods2);

26537
        }

26538


26539
        /* Allocate memory of model methods 3 */

26540
        {

26541
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

26542
            malloc(sizeof(struct _ssSFcnModelMethods3));

26543
          ss_VALIDATE_MEMORY(rts,methods3);

26544
          ssSetModelMethods3(childS, methods3);

26545
        }

26546


26547
        /* Allocate memory for states auxilliary information */

26548
        {

26549
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

26550
            (sizeof(struct _ssStatesInfo2));

26551
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

26552
            malloc(sizeof(ssPeriodicStatesInfo));

26553
          ss_VALIDATE_MEMORY(rts,statesInfo2);

26554
          ssSetStatesInfo2(childS, statesInfo2);

26555
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

26556
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

26557
        }

26558


26559
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

26560
          RegNumInputPorts);

26561
        ssSetRegNumInputPortsFcnArg(childS,childS);

26562


26563
        /* inputs */

26564
        {

26565
          struct _ssPortInputs *inputPortInfo =

26566
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

26567
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

26568
          _ssSetNumInputPorts(childS, 3);

26569
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

26570


26571
          /* port 0 */

26572
          {

26573
            real32_T const **sfcnUPtrs = (real32_T const **)

26574
              malloc(1 * sizeof(real32_T *));

26575
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26576
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

26577
              ssGetLocalBlockIO(rts))->GeneratedSFunction_bb;

26578
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

26579
            _ssSetInputPortNumDimensions(childS, 0, 1);

26580
            ssSetInputPortWidth(childS, 0, 1);

26581
          }

26582


26583
          /* port 1 */

26584
          {

26585
            real32_T const **sfcnUPtrs = (real32_T const **)

26586
              malloc(1 * sizeof(real32_T *));

26587
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26588
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;

26589
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

26590
            _ssSetInputPortNumDimensions(childS, 1, 1);

26591
            ssSetInputPortWidth(childS, 1, 1);

26592
          }

26593


26594
          /* port 2 */

26595
          {

26596
            real32_T const **sfcnUPtrs = (real32_T const **)

26597
              malloc(1 * sizeof(real32_T *));

26598
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26599
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;

26600
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

26601
            _ssSetInputPortNumDimensions(childS, 2, 1);

26602
            ssSetInputPortWidth(childS, 2, 1);

26603
          }

26604
        }

26605


26606
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

26607
          RegNumOutputPorts);

26608
        ssSetRegNumOutputPortsFcnArg(childS,childS);

26609


26610
        /* outputs */

26611
        {

26612
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

26613
            calloc(1, sizeof(struct _ssPortOutputs));

26614
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

26615
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

26616
          _ssSetNumOutputPorts(childS, 1);

26617


26618
          /* port 0 */

26619
          {

26620
            _ssSetOutputPortNumDimensions(childS, 0, 1);

26621
            ssSetOutputPortWidth(childS, 0, 1);

26622
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

26623
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_mq));

26624
          }

26625
        }

26626


26627
        /* path info */

26628
        _ssSetModelName(childS, "SaturationLimiter_sf");

26629
        _ssSetPath(childS,

26630
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/Saturation Limiter1/Generated S-Function1");

26631
        if (ssGetRTModel(rts) == (NULL)) {

26632
          _ssSetParentSS(childS, rts);

26633
          _ssSetRootSS(childS, ssGetRootSS(rts));

26634
        } else {

26635
          ssSetRTModel(childS,ssGetRTModel(rts));

26636
          _ssSetParentSS(childS, (NULL));

26637
          _ssSetRootSS(childS, childS);

26638
        }

26639


26640
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

26641
        (childS)->regDataType.arg1 = ((void *)(childS));

26642
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

26643
          FcnSetErrorStatus);

26644
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

26645
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

26646
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

26647
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

26648


26649
        /* registration */

26650
#if defined(MATLAB_MEX_FILE)

26651


26652
        {

26653
          int_T i;

26654
          mxArray *plhs[1];

26655
          mxArray *prhs[4];

26656
          double *pr;

26657
          volatile int_T *intS = (int_T *)&childS;

26658
          int_T addrlen = sizeof(SimStruct *);

26659
          int_T m = addrlen/sizeof(int_T) + 1;

26660
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

26661
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

26662
          pr = mxGetPr(prhs[1]);

26663
          for (i = 0; i < m - 1; i++) {

26664
            pr[i] = (double)intS[i];

26665
          }

26666


26667
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

26668
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

26669
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

26670


26671
          /* Reset port dimensions info functions because the S-function

26672
           * and accelerator mex-files explicitly set their dimensions,

26673
           * i.e., they are not dynamically sized. For this case, the

26674
           * mex-file is responsible for the dimensions info memory

26675
           * and Simulink should not free it. This is achieved by

26676
           * setting the following two methods to NULL.

26677
           */

26678
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

26679
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

26680


26681
          /*

26682
           * Setup function pointers and call mdlInitializeSizes via

26683
           * simulink.c

26684
           */

26685
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

26686
          mxDestroyArray(plhs[0]);

26687
          mxDestroyArray(prhs[0]);

26688
          mxDestroyArray(prhs[1]);

26689
          mxDestroyArray(prhs[2]);

26690
          mxDestroyArray(prhs[3]);

26691
        }

26692


26693
#else

26694


26695
        {

26696
          SaturationLimiter_sf(childS);

26697
          sfcnInitializeSizes(childS);

26698
        }

26699


26700
#endif

26701


26702
        sfcnInitializeSampleTimes(childS);

26703


26704
        /* adjust sample time */

26705
        ssSetSampleTime(childS, 0, 0.0);

26706
        ssSetOffsetTime(childS, 0, 0.0);

26707
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

26708


26709
        /* set compiled values of dynamic vector attributes */

26710
        ssSetNumNonsampledZCs(childS, 0);

26711


26712
        /* Update connectivity flags for each port */

26713
        _ssSetInputPortConnected(childS, 0, 1);

26714
        _ssSetInputPortConnected(childS, 1, 1);

26715
        _ssSetInputPortConnected(childS, 2, 1);

26716
        _ssSetOutputPortConnected(childS, 0, 1);

26717
        _ssSetOutputPortBeingMerged(childS, 0, 0);

26718


26719
        /* Update the BufferDstPort flags for each input port */

26720
        _ssSetInputPortBufferDstPort(childS, 0, -1);

26721
        _ssSetInputPortBufferDstPort(childS, 1, -1);

26722
        _ssSetInputPortBufferDstPort(childS, 2, -1);

26723
      }

26724


26725
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S199>/Generated S-Function (Gain_sf) */

26726
      {

26727
        SimStruct *childS = ssGetSFunction(rts, 101);

26728


26729
        /* timing info */

26730
        time_T *sfcnPeriod;

26731
        time_T *sfcnOffset;

26732
        int_T *sfcnTsMap;

26733
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

26734
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

26735
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

26736
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

26737
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

26738
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

26739
        (void) memset((void*)sfcnPeriod, 0,

26740
                      sizeof(time_T)*1);

26741
        (void) memset((void*)sfcnOffset, 0,

26742
                      sizeof(time_T)*1);

26743
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

26744
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

26745
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

26746


26747
        /* Set up the mdlInfo pointer */

26748
# ifdef USE_RTMODEL

26749


26750
        {

26751
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

26752
              struct _ssBlkInfo2));

26753
          ss_VALIDATE_MEMORY(rts,blkInfo2);

26754
          ssSetBlkInfo2Ptr(childS, blkInfo2);

26755
        }

26756


26757
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

26758


26759
# else

26760


26761
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

26762


26763
# endif                                /* USE_RTMODEL */

26764


26765
        /* Allocate memory of model methods 2 */

26766
        {

26767
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

26768
            malloc(sizeof(struct _ssSFcnModelMethods2));

26769
          ss_VALIDATE_MEMORY(rts,methods2);

26770
          ssSetModelMethods2(childS, methods2);

26771
        }

26772


26773
        /* Allocate memory of model methods 3 */

26774
        {

26775
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

26776
            malloc(sizeof(struct _ssSFcnModelMethods3));

26777
          ss_VALIDATE_MEMORY(rts,methods3);

26778
          ssSetModelMethods3(childS, methods3);

26779
        }

26780


26781
        /* Allocate memory for states auxilliary information */

26782
        {

26783
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

26784
            (sizeof(struct _ssStatesInfo2));

26785
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

26786
            malloc(sizeof(ssPeriodicStatesInfo));

26787
          ss_VALIDATE_MEMORY(rts,statesInfo2);

26788
          ssSetStatesInfo2(childS, statesInfo2);

26789
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

26790
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

26791
        }

26792


26793
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

26794
          RegNumInputPorts);

26795
        ssSetRegNumInputPortsFcnArg(childS,childS);

26796


26797
        /* inputs */

26798
        {

26799
          struct _ssPortInputs *inputPortInfo =

26800
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

26801
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

26802
          _ssSetNumInputPorts(childS, 2);

26803
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

26804


26805
          /* port 0 */

26806
          {

26807
            real32_T const **sfcnUPtrs = (real32_T const **)

26808
              malloc(1 * sizeof(real32_T *));

26809
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26810
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

26811
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_mq;

26812
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

26813
            _ssSetInputPortNumDimensions(childS, 0, 1);

26814
            ssSetInputPortWidth(childS, 0, 1);

26815
          }

26816


26817
          /* port 1 */

26818
          {

26819
            real32_T const **sfcnUPtrs = (real32_T const **)

26820
              malloc(1 * sizeof(real32_T *));

26821
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

26822
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled122;

26823
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

26824
            _ssSetInputPortNumDimensions(childS, 1, 1);

26825
            ssSetInputPortWidth(childS, 1, 1);

26826
          }

26827
        }

26828


26829
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

26830
          RegNumOutputPorts);

26831
        ssSetRegNumOutputPortsFcnArg(childS,childS);

26832


26833
        /* outputs */

26834
        {

26835
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

26836
            calloc(1, sizeof(struct _ssPortOutputs));

26837
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

26838
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

26839
          _ssSetNumOutputPorts(childS, 1);

26840


26841
          /* port 0 */

26842
          {

26843
            _ssSetOutputPortNumDimensions(childS, 0, 1);

26844
            ssSetOutputPortWidth(childS, 0, 1);

26845
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

26846
              ssGetLocalBlockIO(rts))->GeneratedSFunction_k5));

26847
          }

26848
        }

26849


26850
        /* path info */

26851
        _ssSetModelName(childS, "Gain_sf");

26852
        _ssSetPath(childS,

26853
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/gain2/Generated S-Function");

26854
        if (ssGetRTModel(rts) == (NULL)) {

26855
          _ssSetParentSS(childS, rts);

26856
          _ssSetRootSS(childS, ssGetRootSS(rts));

26857
        } else {

26858
          ssSetRTModel(childS,ssGetRTModel(rts));

26859
          _ssSetParentSS(childS, (NULL));

26860
          _ssSetRootSS(childS, childS);

26861
        }

26862


26863
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

26864
        (childS)->regDataType.arg1 = ((void *)(childS));

26865
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

26866
          FcnSetErrorStatus);

26867
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

26868
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

26869
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

26870
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

26871


26872
        /* registration */

26873
#if defined(MATLAB_MEX_FILE)

26874


26875
        {

26876
          int_T i;

26877
          mxArray *plhs[1];

26878
          mxArray *prhs[4];

26879
          double *pr;

26880
          volatile int_T *intS = (int_T *)&childS;

26881
          int_T addrlen = sizeof(SimStruct *);

26882
          int_T m = addrlen/sizeof(int_T) + 1;

26883
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

26884
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

26885
          pr = mxGetPr(prhs[1]);

26886
          for (i = 0; i < m - 1; i++) {

26887
            pr[i] = (double)intS[i];

26888
          }

26889


26890
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

26891
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

26892
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

26893


26894
          /* Reset port dimensions info functions because the S-function

26895
           * and accelerator mex-files explicitly set their dimensions,

26896
           * i.e., they are not dynamically sized. For this case, the

26897
           * mex-file is responsible for the dimensions info memory

26898
           * and Simulink should not free it. This is achieved by

26899
           * setting the following two methods to NULL.

26900
           */

26901
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

26902
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

26903


26904
          /*

26905
           * Setup function pointers and call mdlInitializeSizes via

26906
           * simulink.c

26907
           */

26908
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

26909
          mxDestroyArray(plhs[0]);

26910
          mxDestroyArray(prhs[0]);

26911
          mxDestroyArray(prhs[1]);

26912
          mxDestroyArray(prhs[2]);

26913
          mxDestroyArray(prhs[3]);

26914
        }

26915


26916
#else

26917


26918
        {

26919
          Gain_sf(childS);

26920
          sfcnInitializeSizes(childS);

26921
        }

26922


26923
#endif

26924


26925
        sfcnInitializeSampleTimes(childS);

26926


26927
        /* adjust sample time */

26928
        ssSetSampleTime(childS, 0, 0.0);

26929
        ssSetOffsetTime(childS, 0, 0.0);

26930
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

26931


26932
        /* set compiled values of dynamic vector attributes */

26933
        ssSetNumNonsampledZCs(childS, 0);

26934


26935
        /* Update connectivity flags for each port */

26936
        _ssSetInputPortConnected(childS, 0, 1);

26937
        _ssSetInputPortConnected(childS, 1, 1);

26938
        _ssSetOutputPortConnected(childS, 0, 1);

26939
        _ssSetOutputPortBeingMerged(childS, 0, 0);

26940


26941
        /* Update the BufferDstPort flags for each input port */

26942
        _ssSetInputPortBufferDstPort(childS, 0, -1);

26943
        _ssSetInputPortBufferDstPort(childS, 1, -1);

26944
      }

26945


26946
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S197>/Generated S-Function2 (LeadLagFilter_sf) */

26947
      {

26948
        SimStruct *childS = ssGetSFunction(rts, 102);

26949


26950
        /* timing info */

26951
        time_T *sfcnPeriod;

26952
        time_T *sfcnOffset;

26953
        int_T *sfcnTsMap;

26954
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

26955
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

26956
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

26957
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

26958
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

26959
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

26960
        (void) memset((void*)sfcnPeriod, 0,

26961
                      sizeof(time_T)*1);

26962
        (void) memset((void*)sfcnOffset, 0,

26963
                      sizeof(time_T)*1);

26964
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

26965
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

26966
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

26967


26968
        /* Set up the mdlInfo pointer */

26969
# ifdef USE_RTMODEL

26970


26971
        {

26972
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

26973
              struct _ssBlkInfo2));

26974
          ss_VALIDATE_MEMORY(rts,blkInfo2);

26975
          ssSetBlkInfo2Ptr(childS, blkInfo2);

26976
        }

26977


26978
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

26979


26980
# else

26981


26982
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

26983


26984
# endif                                /* USE_RTMODEL */

26985


26986
        /* Allocate memory of model methods 2 */

26987
        {

26988
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

26989
            malloc(sizeof(struct _ssSFcnModelMethods2));

26990
          ss_VALIDATE_MEMORY(rts,methods2);

26991
          ssSetModelMethods2(childS, methods2);

26992
        }

26993


26994
        /* Allocate memory of model methods 3 */

26995
        {

26996
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

26997
            malloc(sizeof(struct _ssSFcnModelMethods3));

26998
          ss_VALIDATE_MEMORY(rts,methods3);

26999
          ssSetModelMethods3(childS, methods3);

27000
        }

27001


27002
        /* Allocate memory for states auxilliary information */

27003
        {

27004
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

27005
            (sizeof(struct _ssStatesInfo2));

27006
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

27007
            malloc(sizeof(ssPeriodicStatesInfo));

27008
          ss_VALIDATE_MEMORY(rts,statesInfo2);

27009
          ssSetStatesInfo2(childS, statesInfo2);

27010
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

27011
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

27012
        }

27013


27014
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

27015
          RegNumInputPorts);

27016
        ssSetRegNumInputPortsFcnArg(childS,childS);

27017


27018
        /* inputs */

27019
        {

27020
          struct _ssPortInputs *inputPortInfo =

27021
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

27022
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

27023
          _ssSetNumInputPorts(childS, 7);

27024
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

27025


27026
          /* port 0 */

27027
          {

27028
            real32_T const **sfcnUPtrs = (real32_T const **)

27029
              malloc(1 * sizeof(real32_T *));

27030
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27031
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27032
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

27033
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

27034
            _ssSetInputPortNumDimensions(childS, 0, 1);

27035
            ssSetInputPortWidth(childS, 0, 1);

27036
          }

27037


27038
          /* port 1 */

27039
          {

27040
            int8_T const **sfcnUPtrs = (int8_T const **)

27041
              malloc(1 * sizeof(int8_T *));

27042
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27043
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

27044
              ssGetLocalBlockIO(rts))->DataTypeConversion1_e;

27045
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

27046
            _ssSetInputPortNumDimensions(childS, 1, 1);

27047
            ssSetInputPortWidth(childS, 1, 1);

27048
          }

27049


27050
          /* port 2 */

27051
          {

27052
            real32_T const **sfcnUPtrs = (real32_T const **)

27053
              malloc(1 * sizeof(real32_T *));

27054
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27055
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

27056
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

27057
            _ssSetInputPortNumDimensions(childS, 2, 1);

27058
            ssSetInputPortWidth(childS, 2, 1);

27059
          }

27060


27061
          /* port 3 */

27062
          {

27063
            real32_T const **sfcnUPtrs = (real32_T const **)

27064
              malloc(1 * sizeof(real32_T *));

27065
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27066
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

27067
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

27068
            _ssSetInputPortNumDimensions(childS, 3, 1);

27069
            ssSetInputPortWidth(childS, 3, 1);

27070
          }

27071


27072
          /* port 4 */

27073
          {

27074
            real32_T const **sfcnUPtrs = (real32_T const **)

27075
              malloc(1 * sizeof(real32_T *));

27076
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27077
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27078
              ssGetLocalBlockIO(rts))->Switch_jf;

27079
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

27080
            _ssSetInputPortNumDimensions(childS, 4, 1);

27081
            ssSetInputPortWidth(childS, 4, 1);

27082
          }

27083


27084
          /* port 5 */

27085
          {

27086
            real32_T const **sfcnUPtrs = (real32_T const **)

27087
              malloc(1 * sizeof(real32_T *));

27088
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27089
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27090
              ssGetLocalBlockIO(rts))->Switch_jf;

27091
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

27092
            _ssSetInputPortNumDimensions(childS, 5, 1);

27093
            ssSetInputPortWidth(childS, 5, 1);

27094
          }

27095


27096
          /* port 6 */

27097
          {

27098
            real32_T const **sfcnUPtrs = (real32_T const **)

27099
              malloc(1 * sizeof(real32_T *));

27100
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27101
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27102
              ssGetLocalBlockIO(rts))->GeneratedSFunction_k5;

27103
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

27104
            _ssSetInputPortNumDimensions(childS, 6, 1);

27105
            ssSetInputPortWidth(childS, 6, 1);

27106
          }

27107
        }

27108


27109
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

27110
          RegNumOutputPorts);

27111
        ssSetRegNumOutputPortsFcnArg(childS,childS);

27112


27113
        /* outputs */

27114
        {

27115
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

27116
            calloc(1, sizeof(struct _ssPortOutputs));

27117
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

27118
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

27119
          _ssSetNumOutputPorts(childS, 1);

27120


27121
          /* port 0 */

27122
          {

27123
            _ssSetOutputPortNumDimensions(childS, 0, 1);

27124
            ssSetOutputPortWidth(childS, 0, 1);

27125
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

27126
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_h));

27127
          }

27128
        }

27129


27130
        /* path info */

27131
        _ssSetModelName(childS, "LeadLagFilter_sf");

27132
        _ssSetPath(childS,

27133
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/Lead lag1/Generated S-Function2");

27134
        if (ssGetRTModel(rts) == (NULL)) {

27135
          _ssSetParentSS(childS, rts);

27136
          _ssSetRootSS(childS, ssGetRootSS(rts));

27137
        } else {

27138
          ssSetRTModel(childS,ssGetRTModel(rts));

27139
          _ssSetParentSS(childS, (NULL));

27140
          _ssSetRootSS(childS, childS);

27141
        }

27142


27143
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

27144


27145
        /* work vectors */

27146
        {

27147
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

27148
            (4 * sizeof(struct _ssDWorkRecord));

27149
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

27150
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

27151
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

27152
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

27153
          ssSetSFcnDWork(childS, dWorkRecord);

27154
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

27155
          _ssSetNumDWork(childS, 4);

27156


27157
          /* DWORK0 */

27158
          ssSetDWorkWidth(childS, 0, 1);

27159
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

27160
          ssSetDWorkComplexSignal(childS, 0, 0);

27161
          ssSetDWorkUsedAsDState(childS, 0, 1);

27162
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 223))[0]);

27163


27164
          /* DWORK1 */

27165
          ssSetDWorkWidth(childS, 1, 1);

27166
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

27167
          ssSetDWorkComplexSignal(childS, 1, 0);

27168
          ssSetDWorkUsedAsDState(childS, 1, 1);

27169
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 224))[0]);

27170


27171
          /* DWORK2 */

27172
          ssSetDWorkWidth(childS, 2, 1);

27173
          ssSetDWorkDataType(childS, 2,SS_INT8);

27174
          ssSetDWorkComplexSignal(childS, 2, 0);

27175
          ssSetDWorkUsedAsDState(childS, 2, 1);

27176
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 450))[0]);

27177


27178
          /* DWORK3 */

27179
          ssSetDWorkWidth(childS, 3, 1);

27180
          ssSetDWorkDataType(childS, 3,SS_INT8);

27181
          ssSetDWorkComplexSignal(childS, 3, 0);

27182
          ssSetDWorkUsedAsDState(childS, 3, 1);

27183
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 451))[0]);

27184
        }

27185


27186
        (childS)->regDataType.arg1 = ((void *)(childS));

27187
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

27188
          FcnSetErrorStatus);

27189
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

27190
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

27191
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

27192
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

27193


27194
        /* registration */

27195
#if defined(MATLAB_MEX_FILE)

27196


27197
        {

27198
          int_T i;

27199
          mxArray *plhs[1];

27200
          mxArray *prhs[4];

27201
          double *pr;

27202
          volatile int_T *intS = (int_T *)&childS;

27203
          int_T addrlen = sizeof(SimStruct *);

27204
          int_T m = addrlen/sizeof(int_T) + 1;

27205
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

27206
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

27207
          pr = mxGetPr(prhs[1]);

27208
          for (i = 0; i < m - 1; i++) {

27209
            pr[i] = (double)intS[i];

27210
          }

27211


27212
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

27213
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

27214
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

27215


27216
          /* Reset port dimensions info functions because the S-function

27217
           * and accelerator mex-files explicitly set their dimensions,

27218
           * i.e., they are not dynamically sized. For this case, the

27219
           * mex-file is responsible for the dimensions info memory

27220
           * and Simulink should not free it. This is achieved by

27221
           * setting the following two methods to NULL.

27222
           */

27223
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

27224
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

27225


27226
          /*

27227
           * Setup function pointers and call mdlInitializeSizes via

27228
           * simulink.c

27229
           */

27230
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

27231
          mxDestroyArray(plhs[0]);

27232
          mxDestroyArray(prhs[0]);

27233
          mxDestroyArray(prhs[1]);

27234
          mxDestroyArray(prhs[2]);

27235
          mxDestroyArray(prhs[3]);

27236
        }

27237


27238
#else

27239


27240
        {

27241
          LeadLagFilter_sf(childS);

27242
          sfcnInitializeSizes(childS);

27243
        }

27244


27245
#endif

27246


27247
        sfcnInitializeSampleTimes(childS);

27248


27249
        /* adjust sample time */

27250
        ssSetSampleTime(childS, 0, 0.0);

27251
        ssSetOffsetTime(childS, 0, 0.0);

27252
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

27253


27254
        /* set compiled values of dynamic vector attributes */

27255
        ssSetNumNonsampledZCs(childS, 0);

27256


27257
        /* Update connectivity flags for each port */

27258
        _ssSetInputPortConnected(childS, 0, 1);

27259
        _ssSetInputPortConnected(childS, 1, 1);

27260
        _ssSetInputPortConnected(childS, 2, 1);

27261
        _ssSetInputPortConnected(childS, 3, 1);

27262
        _ssSetInputPortConnected(childS, 4, 1);

27263
        _ssSetInputPortConnected(childS, 5, 1);

27264
        _ssSetInputPortConnected(childS, 6, 1);

27265
        _ssSetOutputPortConnected(childS, 0, 1);

27266
        _ssSetOutputPortBeingMerged(childS, 0, 0);

27267


27268
        /* Update the BufferDstPort flags for each input port */

27269
        _ssSetInputPortBufferDstPort(childS, 0, -1);

27270
        _ssSetInputPortBufferDstPort(childS, 1, -1);

27271
        _ssSetInputPortBufferDstPort(childS, 2, -1);

27272
        _ssSetInputPortBufferDstPort(childS, 3, -1);

27273
        _ssSetInputPortBufferDstPort(childS, 4, -1);

27274
        _ssSetInputPortBufferDstPort(childS, 5, -1);

27275
        _ssSetInputPortBufferDstPort(childS, 6, -1);

27276
      }

27277


27278
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S196>/Generated S-Function4 (LagFilter_sf) */

27279
      {

27280
        SimStruct *childS = ssGetSFunction(rts, 103);

27281


27282
        /* timing info */

27283
        time_T *sfcnPeriod;

27284
        time_T *sfcnOffset;

27285
        int_T *sfcnTsMap;

27286
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

27287
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

27288
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

27289
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

27290
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

27291
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

27292
        (void) memset((void*)sfcnPeriod, 0,

27293
                      sizeof(time_T)*1);

27294
        (void) memset((void*)sfcnOffset, 0,

27295
                      sizeof(time_T)*1);

27296
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

27297
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

27298
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

27299


27300
        /* Set up the mdlInfo pointer */

27301
# ifdef USE_RTMODEL

27302


27303
        {

27304
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

27305
              struct _ssBlkInfo2));

27306
          ss_VALIDATE_MEMORY(rts,blkInfo2);

27307
          ssSetBlkInfo2Ptr(childS, blkInfo2);

27308
        }

27309


27310
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

27311


27312
# else

27313


27314
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

27315


27316
# endif                                /* USE_RTMODEL */

27317


27318
        /* Allocate memory of model methods 2 */

27319
        {

27320
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

27321
            malloc(sizeof(struct _ssSFcnModelMethods2));

27322
          ss_VALIDATE_MEMORY(rts,methods2);

27323
          ssSetModelMethods2(childS, methods2);

27324
        }

27325


27326
        /* Allocate memory of model methods 3 */

27327
        {

27328
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

27329
            malloc(sizeof(struct _ssSFcnModelMethods3));

27330
          ss_VALIDATE_MEMORY(rts,methods3);

27331
          ssSetModelMethods3(childS, methods3);

27332
        }

27333


27334
        /* Allocate memory for states auxilliary information */

27335
        {

27336
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

27337
            (sizeof(struct _ssStatesInfo2));

27338
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

27339
            malloc(sizeof(ssPeriodicStatesInfo));

27340
          ss_VALIDATE_MEMORY(rts,statesInfo2);

27341
          ssSetStatesInfo2(childS, statesInfo2);

27342
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

27343
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

27344
        }

27345


27346
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

27347
          RegNumInputPorts);

27348
        ssSetRegNumInputPortsFcnArg(childS,childS);

27349


27350
        /* inputs */

27351
        {

27352
          struct _ssPortInputs *inputPortInfo =

27353
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

27354
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

27355
          _ssSetNumInputPorts(childS, 6);

27356
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

27357


27358
          /* port 0 */

27359
          {

27360
            real32_T const **sfcnUPtrs = (real32_T const **)

27361
              malloc(1 * sizeof(real32_T *));

27362
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27363
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27364
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

27365
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

27366
            _ssSetInputPortNumDimensions(childS, 0, 1);

27367
            ssSetInputPortWidth(childS, 0, 1);

27368
          }

27369


27370
          /* port 1 */

27371
          {

27372
            int8_T const **sfcnUPtrs = (int8_T const **)

27373
              malloc(1 * sizeof(int8_T *));

27374
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27375
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

27376
              ssGetLocalBlockIO(rts))->DataTypeConversion1_e;

27377
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

27378
            _ssSetInputPortNumDimensions(childS, 1, 1);

27379
            ssSetInputPortWidth(childS, 1, 1);

27380
          }

27381


27382
          /* port 2 */

27383
          {

27384
            real32_T const **sfcnUPtrs = (real32_T const **)

27385
              malloc(1 * sizeof(real32_T *));

27386
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27387
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;

27388
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

27389
            _ssSetInputPortNumDimensions(childS, 2, 1);

27390
            ssSetInputPortWidth(childS, 2, 1);

27391
          }

27392


27393
          /* port 3 */

27394
          {

27395
            real32_T const **sfcnUPtrs = (real32_T const **)

27396
              malloc(1 * sizeof(real32_T *));

27397
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27398
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27399
              ssGetLocalBlockIO(rts))->Switch_jf;

27400
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

27401
            _ssSetInputPortNumDimensions(childS, 3, 1);

27402
            ssSetInputPortWidth(childS, 3, 1);

27403
          }

27404


27405
          /* port 4 */

27406
          {

27407
            real32_T const **sfcnUPtrs = (real32_T const **)

27408
              malloc(1 * sizeof(real32_T *));

27409
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27410
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27411
              ssGetLocalBlockIO(rts))->Switch_jf;

27412
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

27413
            _ssSetInputPortNumDimensions(childS, 4, 1);

27414
            ssSetInputPortWidth(childS, 4, 1);

27415
          }

27416


27417
          /* port 5 */

27418
          {

27419
            real32_T const **sfcnUPtrs = (real32_T const **)

27420
              malloc(1 * sizeof(real32_T *));

27421
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27422
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27423
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_h;

27424
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

27425
            _ssSetInputPortNumDimensions(childS, 5, 1);

27426
            ssSetInputPortWidth(childS, 5, 1);

27427
          }

27428
        }

27429


27430
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

27431
          RegNumOutputPorts);

27432
        ssSetRegNumOutputPortsFcnArg(childS,childS);

27433


27434
        /* outputs */

27435
        {

27436
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

27437
            calloc(1, sizeof(struct _ssPortOutputs));

27438
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

27439
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

27440
          _ssSetNumOutputPorts(childS, 1);

27441


27442
          /* port 0 */

27443
          {

27444
            _ssSetOutputPortNumDimensions(childS, 0, 1);

27445
            ssSetOutputPortWidth(childS, 0, 1);

27446
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

27447
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_a));

27448
          }

27449
        }

27450


27451
        /* path info */

27452
        _ssSetModelName(childS, "LagFilter_sf");

27453
        _ssSetPath(childS,

27454
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/ lag filter/Generated S-Function4");

27455
        if (ssGetRTModel(rts) == (NULL)) {

27456
          _ssSetParentSS(childS, rts);

27457
          _ssSetRootSS(childS, ssGetRootSS(rts));

27458
        } else {

27459
          ssSetRTModel(childS,ssGetRTModel(rts));

27460
          _ssSetParentSS(childS, (NULL));

27461
          _ssSetRootSS(childS, childS);

27462
        }

27463


27464
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

27465


27466
        /* work vectors */

27467
        {

27468
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

27469
            (4 * sizeof(struct _ssDWorkRecord));

27470
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

27471
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

27472
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

27473
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

27474
          ssSetSFcnDWork(childS, dWorkRecord);

27475
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

27476
          _ssSetNumDWork(childS, 4);

27477


27478
          /* DWORK0 */

27479
          ssSetDWorkWidth(childS, 0, 1);

27480
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

27481
          ssSetDWorkComplexSignal(childS, 0, 0);

27482
          ssSetDWorkUsedAsDState(childS, 0, 1);

27483
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 225))[0]);

27484


27485
          /* DWORK1 */

27486
          ssSetDWorkWidth(childS, 1, 1);

27487
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

27488
          ssSetDWorkComplexSignal(childS, 1, 0);

27489
          ssSetDWorkUsedAsDState(childS, 1, 1);

27490
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 226))[0]);

27491


27492
          /* DWORK2 */

27493
          ssSetDWorkWidth(childS, 2, 1);

27494
          ssSetDWorkDataType(childS, 2,SS_INT8);

27495
          ssSetDWorkComplexSignal(childS, 2, 0);

27496
          ssSetDWorkUsedAsDState(childS, 2, 1);

27497
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 452))[0]);

27498


27499
          /* DWORK3 */

27500
          ssSetDWorkWidth(childS, 3, 1);

27501
          ssSetDWorkDataType(childS, 3,SS_INT8);

27502
          ssSetDWorkComplexSignal(childS, 3, 0);

27503
          ssSetDWorkUsedAsDState(childS, 3, 1);

27504
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 453))[0]);

27505
        }

27506


27507
        (childS)->regDataType.arg1 = ((void *)(childS));

27508
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

27509
          FcnSetErrorStatus);

27510
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

27511
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

27512
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

27513
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

27514


27515
        /* registration */

27516
#if defined(MATLAB_MEX_FILE)

27517


27518
        {

27519
          int_T i;

27520
          mxArray *plhs[1];

27521
          mxArray *prhs[4];

27522
          double *pr;

27523
          volatile int_T *intS = (int_T *)&childS;

27524
          int_T addrlen = sizeof(SimStruct *);

27525
          int_T m = addrlen/sizeof(int_T) + 1;

27526
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

27527
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

27528
          pr = mxGetPr(prhs[1]);

27529
          for (i = 0; i < m - 1; i++) {

27530
            pr[i] = (double)intS[i];

27531
          }

27532


27533
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

27534
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

27535
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

27536


27537
          /* Reset port dimensions info functions because the S-function

27538
           * and accelerator mex-files explicitly set their dimensions,

27539
           * i.e., they are not dynamically sized. For this case, the

27540
           * mex-file is responsible for the dimensions info memory

27541
           * and Simulink should not free it. This is achieved by

27542
           * setting the following two methods to NULL.

27543
           */

27544
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

27545
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

27546


27547
          /*

27548
           * Setup function pointers and call mdlInitializeSizes via

27549
           * simulink.c

27550
           */

27551
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

27552
          mxDestroyArray(plhs[0]);

27553
          mxDestroyArray(prhs[0]);

27554
          mxDestroyArray(prhs[1]);

27555
          mxDestroyArray(prhs[2]);

27556
          mxDestroyArray(prhs[3]);

27557
        }

27558


27559
#else

27560


27561
        {

27562
          LagFilter_sf(childS);

27563
          sfcnInitializeSizes(childS);

27564
        }

27565


27566
#endif

27567


27568
        sfcnInitializeSampleTimes(childS);

27569


27570
        /* adjust sample time */

27571
        ssSetSampleTime(childS, 0, 0.0);

27572
        ssSetOffsetTime(childS, 0, 0.0);

27573
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

27574


27575
        /* set compiled values of dynamic vector attributes */

27576
        ssSetNumNonsampledZCs(childS, 0);

27577


27578
        /* Update connectivity flags for each port */

27579
        _ssSetInputPortConnected(childS, 0, 1);

27580
        _ssSetInputPortConnected(childS, 1, 1);

27581
        _ssSetInputPortConnected(childS, 2, 1);

27582
        _ssSetInputPortConnected(childS, 3, 1);

27583
        _ssSetInputPortConnected(childS, 4, 1);

27584
        _ssSetInputPortConnected(childS, 5, 1);

27585
        _ssSetOutputPortConnected(childS, 0, 1);

27586
        _ssSetOutputPortBeingMerged(childS, 0, 0);

27587


27588
        /* Update the BufferDstPort flags for each input port */

27589
        _ssSetInputPortBufferDstPort(childS, 0, -1);

27590
        _ssSetInputPortBufferDstPort(childS, 1, -1);

27591
        _ssSetInputPortBufferDstPort(childS, 2, -1);

27592
        _ssSetInputPortBufferDstPort(childS, 3, -1);

27593
        _ssSetInputPortBufferDstPort(childS, 4, -1);

27594
        _ssSetInputPortBufferDstPort(childS, 5, -1);

27595
      }

27596


27597
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S204>/Generated S-Function (Gain_sf) */

27598
      {

27599
        SimStruct *childS = ssGetSFunction(rts, 104);

27600


27601
        /* timing info */

27602
        time_T *sfcnPeriod;

27603
        time_T *sfcnOffset;

27604
        int_T *sfcnTsMap;

27605
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

27606
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

27607
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

27608
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

27609
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

27610
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

27611
        (void) memset((void*)sfcnPeriod, 0,

27612
                      sizeof(time_T)*1);

27613
        (void) memset((void*)sfcnOffset, 0,

27614
                      sizeof(time_T)*1);

27615
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

27616
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

27617
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

27618


27619
        /* Set up the mdlInfo pointer */

27620
# ifdef USE_RTMODEL

27621


27622
        {

27623
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

27624
              struct _ssBlkInfo2));

27625
          ss_VALIDATE_MEMORY(rts,blkInfo2);

27626
          ssSetBlkInfo2Ptr(childS, blkInfo2);

27627
        }

27628


27629
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

27630


27631
# else

27632


27633
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

27634


27635
# endif                                /* USE_RTMODEL */

27636


27637
        /* Allocate memory of model methods 2 */

27638
        {

27639
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

27640
            malloc(sizeof(struct _ssSFcnModelMethods2));

27641
          ss_VALIDATE_MEMORY(rts,methods2);

27642
          ssSetModelMethods2(childS, methods2);

27643
        }

27644


27645
        /* Allocate memory of model methods 3 */

27646
        {

27647
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

27648
            malloc(sizeof(struct _ssSFcnModelMethods3));

27649
          ss_VALIDATE_MEMORY(rts,methods3);

27650
          ssSetModelMethods3(childS, methods3);

27651
        }

27652


27653
        /* Allocate memory for states auxilliary information */

27654
        {

27655
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

27656
            (sizeof(struct _ssStatesInfo2));

27657
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

27658
            malloc(sizeof(ssPeriodicStatesInfo));

27659
          ss_VALIDATE_MEMORY(rts,statesInfo2);

27660
          ssSetStatesInfo2(childS, statesInfo2);

27661
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

27662
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

27663
        }

27664


27665
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

27666
          RegNumInputPorts);

27667
        ssSetRegNumInputPortsFcnArg(childS,childS);

27668


27669
        /* inputs */

27670
        {

27671
          struct _ssPortInputs *inputPortInfo =

27672
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

27673
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

27674
          _ssSetNumInputPorts(childS, 2);

27675
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

27676


27677
          /* port 0 */

27678
          {

27679
            real32_T const **sfcnUPtrs = (real32_T const **)

27680
              malloc(1 * sizeof(real32_T *));

27681
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27682
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27683
              ssGetLocalBlockIO(rts))->r_n;

27684
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

27685
            _ssSetInputPortNumDimensions(childS, 0, 1);

27686
            ssSetInputPortWidth(childS, 0, 1);

27687
          }

27688


27689
          /* port 1 */

27690
          {

27691
            real32_T const **sfcnUPtrs = (real32_T const **)

27692
              malloc(1 * sizeof(real32_T *));

27693
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27694
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

27695
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

27696
            _ssSetInputPortNumDimensions(childS, 1, 1);

27697
            ssSetInputPortWidth(childS, 1, 1);

27698
          }

27699
        }

27700


27701
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

27702
          RegNumOutputPorts);

27703
        ssSetRegNumOutputPortsFcnArg(childS,childS);

27704


27705
        /* outputs */

27706
        {

27707
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

27708
            calloc(1, sizeof(struct _ssPortOutputs));

27709
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

27710
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

27711
          _ssSetNumOutputPorts(childS, 1);

27712


27713
          /* port 0 */

27714
          {

27715
            _ssSetOutputPortNumDimensions(childS, 0, 1);

27716
            ssSetOutputPortWidth(childS, 0, 1);

27717
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

27718
              ssGetLocalBlockIO(rts))->Saturation8));

27719
          }

27720
        }

27721


27722
        /* path info */

27723
        _ssSetModelName(childS, "Gain_sf");

27724
        _ssSetPath(childS,

27725
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/gain1/Generated S-Function");

27726
        if (ssGetRTModel(rts) == (NULL)) {

27727
          _ssSetParentSS(childS, rts);

27728
          _ssSetRootSS(childS, ssGetRootSS(rts));

27729
        } else {

27730
          ssSetRTModel(childS,ssGetRTModel(rts));

27731
          _ssSetParentSS(childS, (NULL));

27732
          _ssSetRootSS(childS, childS);

27733
        }

27734


27735
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

27736
        (childS)->regDataType.arg1 = ((void *)(childS));

27737
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

27738
          FcnSetErrorStatus);

27739
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

27740
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

27741
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

27742
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

27743


27744
        /* registration */

27745
#if defined(MATLAB_MEX_FILE)

27746


27747
        {

27748
          int_T i;

27749
          mxArray *plhs[1];

27750
          mxArray *prhs[4];

27751
          double *pr;

27752
          volatile int_T *intS = (int_T *)&childS;

27753
          int_T addrlen = sizeof(SimStruct *);

27754
          int_T m = addrlen/sizeof(int_T) + 1;

27755
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

27756
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

27757
          pr = mxGetPr(prhs[1]);

27758
          for (i = 0; i < m - 1; i++) {

27759
            pr[i] = (double)intS[i];

27760
          }

27761


27762
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

27763
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

27764
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

27765


27766
          /* Reset port dimensions info functions because the S-function

27767
           * and accelerator mex-files explicitly set their dimensions,

27768
           * i.e., they are not dynamically sized. For this case, the

27769
           * mex-file is responsible for the dimensions info memory

27770
           * and Simulink should not free it. This is achieved by

27771
           * setting the following two methods to NULL.

27772
           */

27773
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

27774
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

27775


27776
          /*

27777
           * Setup function pointers and call mdlInitializeSizes via

27778
           * simulink.c

27779
           */

27780
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

27781
          mxDestroyArray(plhs[0]);

27782
          mxDestroyArray(prhs[0]);

27783
          mxDestroyArray(prhs[1]);

27784
          mxDestroyArray(prhs[2]);

27785
          mxDestroyArray(prhs[3]);

27786
        }

27787


27788
#else

27789


27790
        {

27791
          Gain_sf(childS);

27792
          sfcnInitializeSizes(childS);

27793
        }

27794


27795
#endif

27796


27797
        sfcnInitializeSampleTimes(childS);

27798


27799
        /* adjust sample time */

27800
        ssSetSampleTime(childS, 0, 0.0);

27801
        ssSetOffsetTime(childS, 0, 0.0);

27802
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

27803


27804
        /* set compiled values of dynamic vector attributes */

27805
        ssSetNumNonsampledZCs(childS, 0);

27806


27807
        /* Update connectivity flags for each port */

27808
        _ssSetInputPortConnected(childS, 0, 1);

27809
        _ssSetInputPortConnected(childS, 1, 1);

27810
        _ssSetOutputPortConnected(childS, 0, 1);

27811
        _ssSetOutputPortBeingMerged(childS, 0, 0);

27812


27813
        /* Update the BufferDstPort flags for each input port */

27814
        _ssSetInputPortBufferDstPort(childS, 0, -1);

27815
        _ssSetInputPortBufferDstPort(childS, 1, -1);

27816
      }

27817


27818
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S203>/Generated S-Function1 (SaturationLimiter_sf) */

27819
      {

27820
        SimStruct *childS = ssGetSFunction(rts, 105);

27821


27822
        /* timing info */

27823
        time_T *sfcnPeriod;

27824
        time_T *sfcnOffset;

27825
        int_T *sfcnTsMap;

27826
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

27827
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

27828
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

27829
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

27830
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

27831
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

27832
        (void) memset((void*)sfcnPeriod, 0,

27833
                      sizeof(time_T)*1);

27834
        (void) memset((void*)sfcnOffset, 0,

27835
                      sizeof(time_T)*1);

27836
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

27837
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

27838
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

27839


27840
        /* Set up the mdlInfo pointer */

27841
# ifdef USE_RTMODEL

27842


27843
        {

27844
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

27845
              struct _ssBlkInfo2));

27846
          ss_VALIDATE_MEMORY(rts,blkInfo2);

27847
          ssSetBlkInfo2Ptr(childS, blkInfo2);

27848
        }

27849


27850
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

27851


27852
# else

27853


27854
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

27855


27856
# endif                                /* USE_RTMODEL */

27857


27858
        /* Allocate memory of model methods 2 */

27859
        {

27860
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

27861
            malloc(sizeof(struct _ssSFcnModelMethods2));

27862
          ss_VALIDATE_MEMORY(rts,methods2);

27863
          ssSetModelMethods2(childS, methods2);

27864
        }

27865


27866
        /* Allocate memory of model methods 3 */

27867
        {

27868
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

27869
            malloc(sizeof(struct _ssSFcnModelMethods3));

27870
          ss_VALIDATE_MEMORY(rts,methods3);

27871
          ssSetModelMethods3(childS, methods3);

27872
        }

27873


27874
        /* Allocate memory for states auxilliary information */

27875
        {

27876
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

27877
            (sizeof(struct _ssStatesInfo2));

27878
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

27879
            malloc(sizeof(ssPeriodicStatesInfo));

27880
          ss_VALIDATE_MEMORY(rts,statesInfo2);

27881
          ssSetStatesInfo2(childS, statesInfo2);

27882
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

27883
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

27884
        }

27885


27886
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

27887
          RegNumInputPorts);

27888
        ssSetRegNumInputPortsFcnArg(childS,childS);

27889


27890
        /* inputs */

27891
        {

27892
          struct _ssPortInputs *inputPortInfo =

27893
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

27894
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

27895
          _ssSetNumInputPorts(childS, 3);

27896
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

27897


27898
          /* port 0 */

27899
          {

27900
            real32_T const **sfcnUPtrs = (real32_T const **)

27901
              malloc(1 * sizeof(real32_T *));

27902
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27903
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

27904
              ssGetLocalBlockIO(rts))->Sum2_eo;

27905
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

27906
            _ssSetInputPortNumDimensions(childS, 0, 1);

27907
            ssSetInputPortWidth(childS, 0, 1);

27908
          }

27909


27910
          /* port 1 */

27911
          {

27912
            real32_T const **sfcnUPtrs = (real32_T const **)

27913
              malloc(1 * sizeof(real32_T *));

27914
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27915
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

27916
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

27917
            _ssSetInputPortNumDimensions(childS, 1, 1);

27918
            ssSetInputPortWidth(childS, 1, 1);

27919
          }

27920


27921
          /* port 2 */

27922
          {

27923
            real32_T const **sfcnUPtrs = (real32_T const **)

27924
              malloc(1 * sizeof(real32_T *));

27925
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

27926
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

27927
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

27928
            _ssSetInputPortNumDimensions(childS, 2, 1);

27929
            ssSetInputPortWidth(childS, 2, 1);

27930
          }

27931
        }

27932


27933
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

27934
          RegNumOutputPorts);

27935
        ssSetRegNumOutputPortsFcnArg(childS,childS);

27936


27937
        /* outputs */

27938
        {

27939
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

27940
            calloc(1, sizeof(struct _ssPortOutputs));

27941
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

27942
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

27943
          _ssSetNumOutputPorts(childS, 1);

27944


27945
          /* port 0 */

27946
          {

27947
            _ssSetOutputPortNumDimensions(childS, 0, 1);

27948
            ssSetOutputPortWidth(childS, 0, 1);

27949
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

27950
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_ov));

27951
          }

27952
        }

27953


27954
        /* path info */

27955
        _ssSetModelName(childS, "SaturationLimiter_sf");

27956
        _ssSetPath(childS,

27957
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Saturation Limiter3/Generated S-Function1");

27958
        if (ssGetRTModel(rts) == (NULL)) {

27959
          _ssSetParentSS(childS, rts);

27960
          _ssSetRootSS(childS, ssGetRootSS(rts));

27961
        } else {

27962
          ssSetRTModel(childS,ssGetRTModel(rts));

27963
          _ssSetParentSS(childS, (NULL));

27964
          _ssSetRootSS(childS, childS);

27965
        }

27966


27967
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

27968
        (childS)->regDataType.arg1 = ((void *)(childS));

27969
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

27970
          FcnSetErrorStatus);

27971
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

27972
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

27973
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

27974
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

27975


27976
        /* registration */

27977
#if defined(MATLAB_MEX_FILE)

27978


27979
        {

27980
          int_T i;

27981
          mxArray *plhs[1];

27982
          mxArray *prhs[4];

27983
          double *pr;

27984
          volatile int_T *intS = (int_T *)&childS;

27985
          int_T addrlen = sizeof(SimStruct *);

27986
          int_T m = addrlen/sizeof(int_T) + 1;

27987
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

27988
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

27989
          pr = mxGetPr(prhs[1]);

27990
          for (i = 0; i < m - 1; i++) {

27991
            pr[i] = (double)intS[i];

27992
          }

27993


27994
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

27995
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

27996
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

27997


27998
          /* Reset port dimensions info functions because the S-function

27999
           * and accelerator mex-files explicitly set their dimensions,

28000
           * i.e., they are not dynamically sized. For this case, the

28001
           * mex-file is responsible for the dimensions info memory

28002
           * and Simulink should not free it. This is achieved by

28003
           * setting the following two methods to NULL.

28004
           */

28005
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

28006
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

28007


28008
          /*

28009
           * Setup function pointers and call mdlInitializeSizes via

28010
           * simulink.c

28011
           */

28012
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

28013
          mxDestroyArray(plhs[0]);

28014
          mxDestroyArray(prhs[0]);

28015
          mxDestroyArray(prhs[1]);

28016
          mxDestroyArray(prhs[2]);

28017
          mxDestroyArray(prhs[3]);

28018
        }

28019


28020
#else

28021


28022
        {

28023
          SaturationLimiter_sf(childS);

28024
          sfcnInitializeSizes(childS);

28025
        }

28026


28027
#endif

28028


28029
        sfcnInitializeSampleTimes(childS);

28030


28031
        /* adjust sample time */

28032
        ssSetSampleTime(childS, 0, 0.0);

28033
        ssSetOffsetTime(childS, 0, 0.0);

28034
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

28035


28036
        /* set compiled values of dynamic vector attributes */

28037
        ssSetNumNonsampledZCs(childS, 0);

28038


28039
        /* Update connectivity flags for each port */

28040
        _ssSetInputPortConnected(childS, 0, 1);

28041
        _ssSetInputPortConnected(childS, 1, 1);

28042
        _ssSetInputPortConnected(childS, 2, 1);

28043
        _ssSetOutputPortConnected(childS, 0, 1);

28044
        _ssSetOutputPortBeingMerged(childS, 0, 0);

28045


28046
        /* Update the BufferDstPort flags for each input port */

28047
        _ssSetInputPortBufferDstPort(childS, 0, -1);

28048
        _ssSetInputPortBufferDstPort(childS, 1, -1);

28049
        _ssSetInputPortBufferDstPort(childS, 2, -1);

28050
      }

28051


28052
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S206>/Generated S-Function (Gain_sf) */

28053
      {

28054
        SimStruct *childS = ssGetSFunction(rts, 106);

28055


28056
        /* timing info */

28057
        time_T *sfcnPeriod;

28058
        time_T *sfcnOffset;

28059
        int_T *sfcnTsMap;

28060
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

28061
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

28062
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

28063
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

28064
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

28065
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

28066
        (void) memset((void*)sfcnPeriod, 0,

28067
                      sizeof(time_T)*1);

28068
        (void) memset((void*)sfcnOffset, 0,

28069
                      sizeof(time_T)*1);

28070
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

28071
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

28072
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

28073


28074
        /* Set up the mdlInfo pointer */

28075
# ifdef USE_RTMODEL

28076


28077
        {

28078
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

28079
              struct _ssBlkInfo2));

28080
          ss_VALIDATE_MEMORY(rts,blkInfo2);

28081
          ssSetBlkInfo2Ptr(childS, blkInfo2);

28082
        }

28083


28084
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

28085


28086
# else

28087


28088
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

28089


28090
# endif                                /* USE_RTMODEL */

28091


28092
        /* Allocate memory of model methods 2 */

28093
        {

28094
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

28095
            malloc(sizeof(struct _ssSFcnModelMethods2));

28096
          ss_VALIDATE_MEMORY(rts,methods2);

28097
          ssSetModelMethods2(childS, methods2);

28098
        }

28099


28100
        /* Allocate memory of model methods 3 */

28101
        {

28102
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

28103
            malloc(sizeof(struct _ssSFcnModelMethods3));

28104
          ss_VALIDATE_MEMORY(rts,methods3);

28105
          ssSetModelMethods3(childS, methods3);

28106
        }

28107


28108
        /* Allocate memory for states auxilliary information */

28109
        {

28110
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

28111
            (sizeof(struct _ssStatesInfo2));

28112
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

28113
            malloc(sizeof(ssPeriodicStatesInfo));

28114
          ss_VALIDATE_MEMORY(rts,statesInfo2);

28115
          ssSetStatesInfo2(childS, statesInfo2);

28116
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

28117
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

28118
        }

28119


28120
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

28121
          RegNumInputPorts);

28122
        ssSetRegNumInputPortsFcnArg(childS,childS);

28123


28124
        /* inputs */

28125
        {

28126
          struct _ssPortInputs *inputPortInfo =

28127
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

28128
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

28129
          _ssSetNumInputPorts(childS, 2);

28130
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

28131


28132
          /* port 0 */

28133
          {

28134
            real32_T const **sfcnUPtrs = (real32_T const **)

28135
              malloc(1 * sizeof(real32_T *));

28136
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28137
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

28138
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_ov;

28139
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

28140
            _ssSetInputPortNumDimensions(childS, 0, 1);

28141
            ssSetInputPortWidth(childS, 0, 1);

28142
          }

28143


28144
          /* port 1 */

28145
          {

28146
            real32_T const **sfcnUPtrs = (real32_T const **)

28147
              malloc(1 * sizeof(real32_T *));

28148
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28149
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

28150
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

28151
            _ssSetInputPortNumDimensions(childS, 1, 1);

28152
            ssSetInputPortWidth(childS, 1, 1);

28153
          }

28154
        }

28155


28156
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

28157
          RegNumOutputPorts);

28158
        ssSetRegNumOutputPortsFcnArg(childS,childS);

28159


28160
        /* outputs */

28161
        {

28162
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

28163
            calloc(1, sizeof(struct _ssPortOutputs));

28164
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

28165
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

28166
          _ssSetNumOutputPorts(childS, 1);

28167


28168
          /* port 0 */

28169
          {

28170
            _ssSetOutputPortNumDimensions(childS, 0, 1);

28171
            ssSetOutputPortWidth(childS, 0, 1);

28172
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

28173
              ssGetLocalBlockIO(rts))->MinMax));

28174
          }

28175
        }

28176


28177
        /* path info */

28178
        _ssSetModelName(childS, "Gain_sf");

28179
        _ssSetPath(childS,

28180
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/gain3/Generated S-Function");

28181
        if (ssGetRTModel(rts) == (NULL)) {

28182
          _ssSetParentSS(childS, rts);

28183
          _ssSetRootSS(childS, ssGetRootSS(rts));

28184
        } else {

28185
          ssSetRTModel(childS,ssGetRTModel(rts));

28186
          _ssSetParentSS(childS, (NULL));

28187
          _ssSetRootSS(childS, childS);

28188
        }

28189


28190
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

28191
        (childS)->regDataType.arg1 = ((void *)(childS));

28192
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

28193
          FcnSetErrorStatus);

28194
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

28195
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

28196
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

28197
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

28198


28199
        /* registration */

28200
#if defined(MATLAB_MEX_FILE)

28201


28202
        {

28203
          int_T i;

28204
          mxArray *plhs[1];

28205
          mxArray *prhs[4];

28206
          double *pr;

28207
          volatile int_T *intS = (int_T *)&childS;

28208
          int_T addrlen = sizeof(SimStruct *);

28209
          int_T m = addrlen/sizeof(int_T) + 1;

28210
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

28211
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

28212
          pr = mxGetPr(prhs[1]);

28213
          for (i = 0; i < m - 1; i++) {

28214
            pr[i] = (double)intS[i];

28215
          }

28216


28217
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

28218
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

28219
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

28220


28221
          /* Reset port dimensions info functions because the S-function

28222
           * and accelerator mex-files explicitly set their dimensions,

28223
           * i.e., they are not dynamically sized. For this case, the

28224
           * mex-file is responsible for the dimensions info memory

28225
           * and Simulink should not free it. This is achieved by

28226
           * setting the following two methods to NULL.

28227
           */

28228
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

28229
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

28230


28231
          /*

28232
           * Setup function pointers and call mdlInitializeSizes via

28233
           * simulink.c

28234
           */

28235
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

28236
          mxDestroyArray(plhs[0]);

28237
          mxDestroyArray(prhs[0]);

28238
          mxDestroyArray(prhs[1]);

28239
          mxDestroyArray(prhs[2]);

28240
          mxDestroyArray(prhs[3]);

28241
        }

28242


28243
#else

28244


28245
        {

28246
          Gain_sf(childS);

28247
          sfcnInitializeSizes(childS);

28248
        }

28249


28250
#endif

28251


28252
        sfcnInitializeSampleTimes(childS);

28253


28254
        /* adjust sample time */

28255
        ssSetSampleTime(childS, 0, 0.0);

28256
        ssSetOffsetTime(childS, 0, 0.0);

28257
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

28258


28259
        /* set compiled values of dynamic vector attributes */

28260
        ssSetNumNonsampledZCs(childS, 0);

28261


28262
        /* Update connectivity flags for each port */

28263
        _ssSetInputPortConnected(childS, 0, 1);

28264
        _ssSetInputPortConnected(childS, 1, 1);

28265
        _ssSetOutputPortConnected(childS, 0, 1);

28266
        _ssSetOutputPortBeingMerged(childS, 0, 0);

28267


28268
        /* Update the BufferDstPort flags for each input port */

28269
        _ssSetInputPortBufferDstPort(childS, 0, -1);

28270
        _ssSetInputPortBufferDstPort(childS, 1, -1);

28271
      }

28272


28273
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S194>/Generated S-Function6 (Res180_sf) */

28274
      {

28275
        SimStruct *childS = ssGetSFunction(rts, 107);

28276


28277
        /* timing info */

28278
        time_T *sfcnPeriod;

28279
        time_T *sfcnOffset;

28280
        int_T *sfcnTsMap;

28281
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

28282
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

28283
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

28284
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

28285
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

28286
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

28287
        (void) memset((void*)sfcnPeriod, 0,

28288
                      sizeof(time_T)*1);

28289
        (void) memset((void*)sfcnOffset, 0,

28290
                      sizeof(time_T)*1);

28291
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

28292
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

28293
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

28294


28295
        /* Set up the mdlInfo pointer */

28296
# ifdef USE_RTMODEL

28297


28298
        {

28299
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

28300
              struct _ssBlkInfo2));

28301
          ss_VALIDATE_MEMORY(rts,blkInfo2);

28302
          ssSetBlkInfo2Ptr(childS, blkInfo2);

28303
        }

28304


28305
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

28306


28307
# else

28308


28309
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

28310


28311
# endif                                /* USE_RTMODEL */

28312


28313
        /* Allocate memory of model methods 2 */

28314
        {

28315
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

28316
            malloc(sizeof(struct _ssSFcnModelMethods2));

28317
          ss_VALIDATE_MEMORY(rts,methods2);

28318
          ssSetModelMethods2(childS, methods2);

28319
        }

28320


28321
        /* Allocate memory of model methods 3 */

28322
        {

28323
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

28324
            malloc(sizeof(struct _ssSFcnModelMethods3));

28325
          ss_VALIDATE_MEMORY(rts,methods3);

28326
          ssSetModelMethods3(childS, methods3);

28327
        }

28328


28329
        /* Allocate memory for states auxilliary information */

28330
        {

28331
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

28332
            (sizeof(struct _ssStatesInfo2));

28333
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

28334
            malloc(sizeof(ssPeriodicStatesInfo));

28335
          ss_VALIDATE_MEMORY(rts,statesInfo2);

28336
          ssSetStatesInfo2(childS, statesInfo2);

28337
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

28338
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

28339
        }

28340


28341
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

28342
          RegNumInputPorts);

28343
        ssSetRegNumInputPortsFcnArg(childS,childS);

28344


28345
        /* inputs */

28346
        {

28347
          struct _ssPortInputs *inputPortInfo =

28348
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

28349
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

28350
          _ssSetNumInputPorts(childS, 1);

28351
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

28352


28353
          /* port 0 */

28354
          {

28355
            real32_T const **sfcnUPtrs = (real32_T const **)

28356
              malloc(1 * sizeof(real32_T *));

28357
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28358
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

28359
              ssGetLocalBlockIO(rts))->Sum3_k;

28360
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

28361
            _ssSetInputPortNumDimensions(childS, 0, 1);

28362
            ssSetInputPortWidth(childS, 0, 1);

28363
          }

28364
        }

28365


28366
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

28367
          RegNumOutputPorts);

28368
        ssSetRegNumOutputPortsFcnArg(childS,childS);

28369


28370
        /* outputs */

28371
        {

28372
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

28373
            calloc(1, sizeof(struct _ssPortOutputs));

28374
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

28375
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

28376
          _ssSetNumOutputPorts(childS, 1);

28377


28378
          /* port 0 */

28379
          {

28380
            _ssSetOutputPortNumDimensions(childS, 0, 1);

28381
            ssSetOutputPortWidth(childS, 0, 1);

28382
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

28383
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_aa));

28384
          }

28385
        }

28386


28387
        /* path info */

28388
        _ssSetModelName(childS, "Res180_sf");

28389
        _ssSetPath(childS,

28390
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Generated S-Function6");

28391
        if (ssGetRTModel(rts) == (NULL)) {

28392
          _ssSetParentSS(childS, rts);

28393
          _ssSetRootSS(childS, ssGetRootSS(rts));

28394
        } else {

28395
          ssSetRTModel(childS,ssGetRTModel(rts));

28396
          _ssSetParentSS(childS, (NULL));

28397
          _ssSetRootSS(childS, childS);

28398
        }

28399


28400
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

28401
        (childS)->regDataType.arg1 = ((void *)(childS));

28402
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

28403
          FcnSetErrorStatus);

28404
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

28405
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

28406
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

28407
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

28408


28409
        /* registration */

28410
#if defined(MATLAB_MEX_FILE)

28411


28412
        {

28413
          int_T i;

28414
          mxArray *plhs[1];

28415
          mxArray *prhs[4];

28416
          double *pr;

28417
          volatile int_T *intS = (int_T *)&childS;

28418
          int_T addrlen = sizeof(SimStruct *);

28419
          int_T m = addrlen/sizeof(int_T) + 1;

28420
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

28421
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

28422
          pr = mxGetPr(prhs[1]);

28423
          for (i = 0; i < m - 1; i++) {

28424
            pr[i] = (double)intS[i];

28425
          }

28426


28427
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

28428
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

28429
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

28430


28431
          /* Reset port dimensions info functions because the S-function

28432
           * and accelerator mex-files explicitly set their dimensions,

28433
           * i.e., they are not dynamically sized. For this case, the

28434
           * mex-file is responsible for the dimensions info memory

28435
           * and Simulink should not free it. This is achieved by

28436
           * setting the following two methods to NULL.

28437
           */

28438
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

28439
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

28440


28441
          /*

28442
           * Setup function pointers and call mdlInitializeSizes via

28443
           * simulink.c

28444
           */

28445
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

28446
          mxDestroyArray(plhs[0]);

28447
          mxDestroyArray(prhs[0]);

28448
          mxDestroyArray(prhs[1]);

28449
          mxDestroyArray(prhs[2]);

28450
          mxDestroyArray(prhs[3]);

28451
        }

28452


28453
#else

28454


28455
        {

28456
          Res180_sf(childS);

28457
          sfcnInitializeSizes(childS);

28458
        }

28459


28460
#endif

28461


28462
        sfcnInitializeSampleTimes(childS);

28463


28464
        /* adjust sample time */

28465
        ssSetSampleTime(childS, 0, 0.0);

28466
        ssSetOffsetTime(childS, 0, 0.0);

28467
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

28468


28469
        /* set compiled values of dynamic vector attributes */

28470
        ssSetNumNonsampledZCs(childS, 0);

28471


28472
        /* Update connectivity flags for each port */

28473
        _ssSetInputPortConnected(childS, 0, 1);

28474
        _ssSetOutputPortConnected(childS, 0, 1);

28475
        _ssSetOutputPortBeingMerged(childS, 0, 0);

28476


28477
        /* Update the BufferDstPort flags for each input port */

28478
        _ssSetInputPortBufferDstPort(childS, 0, -1);

28479
      }

28480


28481
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S202>/Generated S-Function1 (SaturationLimiter_sf) */

28482
      {

28483
        SimStruct *childS = ssGetSFunction(rts, 108);

28484


28485
        /* timing info */

28486
        time_T *sfcnPeriod;

28487
        time_T *sfcnOffset;

28488
        int_T *sfcnTsMap;

28489
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

28490
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

28491
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

28492
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

28493
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

28494
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

28495
        (void) memset((void*)sfcnPeriod, 0,

28496
                      sizeof(time_T)*1);

28497
        (void) memset((void*)sfcnOffset, 0,

28498
                      sizeof(time_T)*1);

28499
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

28500
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

28501
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

28502


28503
        /* Set up the mdlInfo pointer */

28504
# ifdef USE_RTMODEL

28505


28506
        {

28507
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

28508
              struct _ssBlkInfo2));

28509
          ss_VALIDATE_MEMORY(rts,blkInfo2);

28510
          ssSetBlkInfo2Ptr(childS, blkInfo2);

28511
        }

28512


28513
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

28514


28515
# else

28516


28517
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

28518


28519
# endif                                /* USE_RTMODEL */

28520


28521
        /* Allocate memory of model methods 2 */

28522
        {

28523
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

28524
            malloc(sizeof(struct _ssSFcnModelMethods2));

28525
          ss_VALIDATE_MEMORY(rts,methods2);

28526
          ssSetModelMethods2(childS, methods2);

28527
        }

28528


28529
        /* Allocate memory of model methods 3 */

28530
        {

28531
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

28532
            malloc(sizeof(struct _ssSFcnModelMethods3));

28533
          ss_VALIDATE_MEMORY(rts,methods3);

28534
          ssSetModelMethods3(childS, methods3);

28535
        }

28536


28537
        /* Allocate memory for states auxilliary information */

28538
        {

28539
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

28540
            (sizeof(struct _ssStatesInfo2));

28541
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

28542
            malloc(sizeof(ssPeriodicStatesInfo));

28543
          ss_VALIDATE_MEMORY(rts,statesInfo2);

28544
          ssSetStatesInfo2(childS, statesInfo2);

28545
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

28546
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

28547
        }

28548


28549
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

28550
          RegNumInputPorts);

28551
        ssSetRegNumInputPortsFcnArg(childS,childS);

28552


28553
        /* inputs */

28554
        {

28555
          struct _ssPortInputs *inputPortInfo =

28556
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

28557
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

28558
          _ssSetNumInputPorts(childS, 3);

28559
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

28560


28561
          /* port 0 */

28562
          {

28563
            real32_T const **sfcnUPtrs = (real32_T const **)

28564
              malloc(1 * sizeof(real32_T *));

28565
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28566
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

28567
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_aa;

28568
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

28569
            _ssSetInputPortNumDimensions(childS, 0, 1);

28570
            ssSetInputPortWidth(childS, 0, 1);

28571
          }

28572


28573
          /* port 1 */

28574
          {

28575
            real32_T const **sfcnUPtrs = (real32_T const **)

28576
              malloc(1 * sizeof(real32_T *));

28577
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28578
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;

28579
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

28580
            _ssSetInputPortNumDimensions(childS, 1, 1);

28581
            ssSetInputPortWidth(childS, 1, 1);

28582
          }

28583


28584
          /* port 2 */

28585
          {

28586
            real32_T const **sfcnUPtrs = (real32_T const **)

28587
              malloc(1 * sizeof(real32_T *));

28588
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28589
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;

28590
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

28591
            _ssSetInputPortNumDimensions(childS, 2, 1);

28592
            ssSetInputPortWidth(childS, 2, 1);

28593
          }

28594
        }

28595


28596
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

28597
          RegNumOutputPorts);

28598
        ssSetRegNumOutputPortsFcnArg(childS,childS);

28599


28600
        /* outputs */

28601
        {

28602
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

28603
            calloc(1, sizeof(struct _ssPortOutputs));

28604
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

28605
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

28606
          _ssSetNumOutputPorts(childS, 1);

28607


28608
          /* port 0 */

28609
          {

28610
            _ssSetOutputPortNumDimensions(childS, 0, 1);

28611
            ssSetOutputPortWidth(childS, 0, 1);

28612
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

28613
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_dm));

28614
          }

28615
        }

28616


28617
        /* path info */

28618
        _ssSetModelName(childS, "SaturationLimiter_sf");

28619
        _ssSetPath(childS,

28620
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Saturation Limiter1/Generated S-Function1");

28621
        if (ssGetRTModel(rts) == (NULL)) {

28622
          _ssSetParentSS(childS, rts);

28623
          _ssSetRootSS(childS, ssGetRootSS(rts));

28624
        } else {

28625
          ssSetRTModel(childS,ssGetRTModel(rts));

28626
          _ssSetParentSS(childS, (NULL));

28627
          _ssSetRootSS(childS, childS);

28628
        }

28629


28630
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

28631
        (childS)->regDataType.arg1 = ((void *)(childS));

28632
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

28633
          FcnSetErrorStatus);

28634
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

28635
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

28636
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

28637
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

28638


28639
        /* registration */

28640
#if defined(MATLAB_MEX_FILE)

28641


28642
        {

28643
          int_T i;

28644
          mxArray *plhs[1];

28645
          mxArray *prhs[4];

28646
          double *pr;

28647
          volatile int_T *intS = (int_T *)&childS;

28648
          int_T addrlen = sizeof(SimStruct *);

28649
          int_T m = addrlen/sizeof(int_T) + 1;

28650
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

28651
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

28652
          pr = mxGetPr(prhs[1]);

28653
          for (i = 0; i < m - 1; i++) {

28654
            pr[i] = (double)intS[i];

28655
          }

28656


28657
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

28658
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

28659
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

28660


28661
          /* Reset port dimensions info functions because the S-function

28662
           * and accelerator mex-files explicitly set their dimensions,

28663
           * i.e., they are not dynamically sized. For this case, the

28664
           * mex-file is responsible for the dimensions info memory

28665
           * and Simulink should not free it. This is achieved by

28666
           * setting the following two methods to NULL.

28667
           */

28668
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

28669
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

28670


28671
          /*

28672
           * Setup function pointers and call mdlInitializeSizes via

28673
           * simulink.c

28674
           */

28675
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

28676
          mxDestroyArray(plhs[0]);

28677
          mxDestroyArray(prhs[0]);

28678
          mxDestroyArray(prhs[1]);

28679
          mxDestroyArray(prhs[2]);

28680
          mxDestroyArray(prhs[3]);

28681
        }

28682


28683
#else

28684


28685
        {

28686
          SaturationLimiter_sf(childS);

28687
          sfcnInitializeSizes(childS);

28688
        }

28689


28690
#endif

28691


28692
        sfcnInitializeSampleTimes(childS);

28693


28694
        /* adjust sample time */

28695
        ssSetSampleTime(childS, 0, 0.0);

28696
        ssSetOffsetTime(childS, 0, 0.0);

28697
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

28698


28699
        /* set compiled values of dynamic vector attributes */

28700
        ssSetNumNonsampledZCs(childS, 0);

28701


28702
        /* Update connectivity flags for each port */

28703
        _ssSetInputPortConnected(childS, 0, 1);

28704
        _ssSetInputPortConnected(childS, 1, 1);

28705
        _ssSetInputPortConnected(childS, 2, 1);

28706
        _ssSetOutputPortConnected(childS, 0, 1);

28707
        _ssSetOutputPortBeingMerged(childS, 0, 0);

28708


28709
        /* Update the BufferDstPort flags for each input port */

28710
        _ssSetInputPortBufferDstPort(childS, 0, -1);

28711
        _ssSetInputPortBufferDstPort(childS, 1, -1);

28712
        _ssSetInputPortBufferDstPort(childS, 2, -1);

28713
      }

28714


28715
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S205>/Generated S-Function (Gain_sf) */

28716
      {

28717
        SimStruct *childS = ssGetSFunction(rts, 109);

28718


28719
        /* timing info */

28720
        time_T *sfcnPeriod;

28721
        time_T *sfcnOffset;

28722
        int_T *sfcnTsMap;

28723
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

28724
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

28725
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

28726
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

28727
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

28728
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

28729
        (void) memset((void*)sfcnPeriod, 0,

28730
                      sizeof(time_T)*1);

28731
        (void) memset((void*)sfcnOffset, 0,

28732
                      sizeof(time_T)*1);

28733
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

28734
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

28735
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

28736


28737
        /* Set up the mdlInfo pointer */

28738
# ifdef USE_RTMODEL

28739


28740
        {

28741
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

28742
              struct _ssBlkInfo2));

28743
          ss_VALIDATE_MEMORY(rts,blkInfo2);

28744
          ssSetBlkInfo2Ptr(childS, blkInfo2);

28745
        }

28746


28747
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

28748


28749
# else

28750


28751
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

28752


28753
# endif                                /* USE_RTMODEL */

28754


28755
        /* Allocate memory of model methods 2 */

28756
        {

28757
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

28758
            malloc(sizeof(struct _ssSFcnModelMethods2));

28759
          ss_VALIDATE_MEMORY(rts,methods2);

28760
          ssSetModelMethods2(childS, methods2);

28761
        }

28762


28763
        /* Allocate memory of model methods 3 */

28764
        {

28765
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

28766
            malloc(sizeof(struct _ssSFcnModelMethods3));

28767
          ss_VALIDATE_MEMORY(rts,methods3);

28768
          ssSetModelMethods3(childS, methods3);

28769
        }

28770


28771
        /* Allocate memory for states auxilliary information */

28772
        {

28773
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

28774
            (sizeof(struct _ssStatesInfo2));

28775
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

28776
            malloc(sizeof(ssPeriodicStatesInfo));

28777
          ss_VALIDATE_MEMORY(rts,statesInfo2);

28778
          ssSetStatesInfo2(childS, statesInfo2);

28779
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

28780
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

28781
        }

28782


28783
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

28784
          RegNumInputPorts);

28785
        ssSetRegNumInputPortsFcnArg(childS,childS);

28786


28787
        /* inputs */

28788
        {

28789
          struct _ssPortInputs *inputPortInfo =

28790
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

28791
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

28792
          _ssSetNumInputPorts(childS, 2);

28793
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

28794


28795
          /* port 0 */

28796
          {

28797
            real32_T const **sfcnUPtrs = (real32_T const **)

28798
              malloc(1 * sizeof(real32_T *));

28799
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28800
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

28801
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_dm;

28802
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

28803
            _ssSetInputPortNumDimensions(childS, 0, 1);

28804
            ssSetInputPortWidth(childS, 0, 1);

28805
          }

28806


28807
          /* port 1 */

28808
          {

28809
            real32_T const **sfcnUPtrs = (real32_T const **)

28810
              malloc(1 * sizeof(real32_T *));

28811
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

28812
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

28813
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

28814
            _ssSetInputPortNumDimensions(childS, 1, 1);

28815
            ssSetInputPortWidth(childS, 1, 1);

28816
          }

28817
        }

28818


28819
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

28820
          RegNumOutputPorts);

28821
        ssSetRegNumOutputPortsFcnArg(childS,childS);

28822


28823
        /* outputs */

28824
        {

28825
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

28826
            calloc(1, sizeof(struct _ssPortOutputs));

28827
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

28828
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

28829
          _ssSetNumOutputPorts(childS, 1);

28830


28831
          /* port 0 */

28832
          {

28833
            _ssSetOutputPortNumDimensions(childS, 0, 1);

28834
            ssSetOutputPortWidth(childS, 0, 1);

28835
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

28836
              ssGetLocalBlockIO(rts))->GeneratedSFunction_pk));

28837
          }

28838
        }

28839


28840
        /* path info */

28841
        _ssSetModelName(childS, "Gain_sf");

28842
        _ssSetPath(childS,

28843
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/gain2/Generated S-Function");

28844
        if (ssGetRTModel(rts) == (NULL)) {

28845
          _ssSetParentSS(childS, rts);

28846
          _ssSetRootSS(childS, ssGetRootSS(rts));

28847
        } else {

28848
          ssSetRTModel(childS,ssGetRTModel(rts));

28849
          _ssSetParentSS(childS, (NULL));

28850
          _ssSetRootSS(childS, childS);

28851
        }

28852


28853
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

28854
        (childS)->regDataType.arg1 = ((void *)(childS));

28855
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

28856
          FcnSetErrorStatus);

28857
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

28858
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

28859
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

28860
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

28861


28862
        /* registration */

28863
#if defined(MATLAB_MEX_FILE)

28864


28865
        {

28866
          int_T i;

28867
          mxArray *plhs[1];

28868
          mxArray *prhs[4];

28869
          double *pr;

28870
          volatile int_T *intS = (int_T *)&childS;

28871
          int_T addrlen = sizeof(SimStruct *);

28872
          int_T m = addrlen/sizeof(int_T) + 1;

28873
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

28874
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

28875
          pr = mxGetPr(prhs[1]);

28876
          for (i = 0; i < m - 1; i++) {

28877
            pr[i] = (double)intS[i];

28878
          }

28879


28880
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

28881
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

28882
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

28883


28884
          /* Reset port dimensions info functions because the S-function

28885
           * and accelerator mex-files explicitly set their dimensions,

28886
           * i.e., they are not dynamically sized. For this case, the

28887
           * mex-file is responsible for the dimensions info memory

28888
           * and Simulink should not free it. This is achieved by

28889
           * setting the following two methods to NULL.

28890
           */

28891
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

28892
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

28893


28894
          /*

28895
           * Setup function pointers and call mdlInitializeSizes via

28896
           * simulink.c

28897
           */

28898
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

28899
          mxDestroyArray(plhs[0]);

28900
          mxDestroyArray(prhs[0]);

28901
          mxDestroyArray(prhs[1]);

28902
          mxDestroyArray(prhs[2]);

28903
          mxDestroyArray(prhs[3]);

28904
        }

28905


28906
#else

28907


28908
        {

28909
          Gain_sf(childS);

28910
          sfcnInitializeSizes(childS);

28911
        }

28912


28913
#endif

28914


28915
        sfcnInitializeSampleTimes(childS);

28916


28917
        /* adjust sample time */

28918
        ssSetSampleTime(childS, 0, 0.0);

28919
        ssSetOffsetTime(childS, 0, 0.0);

28920
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

28921


28922
        /* set compiled values of dynamic vector attributes */

28923
        ssSetNumNonsampledZCs(childS, 0);

28924


28925
        /* Update connectivity flags for each port */

28926
        _ssSetInputPortConnected(childS, 0, 1);

28927
        _ssSetInputPortConnected(childS, 1, 1);

28928
        _ssSetOutputPortConnected(childS, 0, 1);

28929
        _ssSetOutputPortBeingMerged(childS, 0, 0);

28930


28931
        /* Update the BufferDstPort flags for each input port */

28932
        _ssSetInputPortBufferDstPort(childS, 0, -1);

28933
        _ssSetInputPortBufferDstPort(childS, 1, -1);

28934
      }

28935


28936
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S201>/Generated S-Function2 (LeadLagFilter_sf) */

28937
      {

28938
        SimStruct *childS = ssGetSFunction(rts, 110);

28939


28940
        /* timing info */

28941
        time_T *sfcnPeriod;

28942
        time_T *sfcnOffset;

28943
        int_T *sfcnTsMap;

28944
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

28945
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

28946
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

28947
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

28948
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

28949
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

28950
        (void) memset((void*)sfcnPeriod, 0,

28951
                      sizeof(time_T)*1);

28952
        (void) memset((void*)sfcnOffset, 0,

28953
                      sizeof(time_T)*1);

28954
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

28955
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

28956
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

28957


28958
        /* Set up the mdlInfo pointer */

28959
# ifdef USE_RTMODEL

28960


28961
        {

28962
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

28963
              struct _ssBlkInfo2));

28964
          ss_VALIDATE_MEMORY(rts,blkInfo2);

28965
          ssSetBlkInfo2Ptr(childS, blkInfo2);

28966
        }

28967


28968
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

28969


28970
# else

28971


28972
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

28973


28974
# endif                                /* USE_RTMODEL */

28975


28976
        /* Allocate memory of model methods 2 */

28977
        {

28978
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

28979
            malloc(sizeof(struct _ssSFcnModelMethods2));

28980
          ss_VALIDATE_MEMORY(rts,methods2);

28981
          ssSetModelMethods2(childS, methods2);

28982
        }

28983


28984
        /* Allocate memory of model methods 3 */

28985
        {

28986
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

28987
            malloc(sizeof(struct _ssSFcnModelMethods3));

28988
          ss_VALIDATE_MEMORY(rts,methods3);

28989
          ssSetModelMethods3(childS, methods3);

28990
        }

28991


28992
        /* Allocate memory for states auxilliary information */

28993
        {

28994
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

28995
            (sizeof(struct _ssStatesInfo2));

28996
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

28997
            malloc(sizeof(ssPeriodicStatesInfo));

28998
          ss_VALIDATE_MEMORY(rts,statesInfo2);

28999
          ssSetStatesInfo2(childS, statesInfo2);

29000
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

29001
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

29002
        }

29003


29004
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

29005
          RegNumInputPorts);

29006
        ssSetRegNumInputPortsFcnArg(childS,childS);

29007


29008
        /* inputs */

29009
        {

29010
          struct _ssPortInputs *inputPortInfo =

29011
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

29012
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

29013
          _ssSetNumInputPorts(childS, 7);

29014
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

29015


29016
          /* port 0 */

29017
          {

29018
            real32_T const **sfcnUPtrs = (real32_T const **)

29019
              malloc(1 * sizeof(real32_T *));

29020
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29021
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29022
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

29023
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

29024
            _ssSetInputPortNumDimensions(childS, 0, 1);

29025
            ssSetInputPortWidth(childS, 0, 1);

29026
          }

29027


29028
          /* port 1 */

29029
          {

29030
            int8_T const **sfcnUPtrs = (int8_T const **)

29031
              malloc(1 * sizeof(int8_T *));

29032
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29033
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

29034
              ssGetLocalBlockIO(rts))->DataTypeConversion2_j;

29035
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

29036
            _ssSetInputPortNumDimensions(childS, 1, 1);

29037
            ssSetInputPortWidth(childS, 1, 1);

29038
          }

29039


29040
          /* port 2 */

29041
          {

29042
            real32_T const **sfcnUPtrs = (real32_T const **)

29043
              malloc(1 * sizeof(real32_T *));

29044
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29045
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

29046
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

29047
            _ssSetInputPortNumDimensions(childS, 2, 1);

29048
            ssSetInputPortWidth(childS, 2, 1);

29049
          }

29050


29051
          /* port 3 */

29052
          {

29053
            real32_T const **sfcnUPtrs = (real32_T const **)

29054
              malloc(1 * sizeof(real32_T *));

29055
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29056
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

29057
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

29058
            _ssSetInputPortNumDimensions(childS, 3, 1);

29059
            ssSetInputPortWidth(childS, 3, 1);

29060
          }

29061


29062
          /* port 4 */

29063
          {

29064
            real32_T const **sfcnUPtrs = (real32_T const **)

29065
              malloc(1 * sizeof(real32_T *));

29066
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29067
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29068
              ssGetLocalBlockIO(rts))->Switch_jf;

29069
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

29070
            _ssSetInputPortNumDimensions(childS, 4, 1);

29071
            ssSetInputPortWidth(childS, 4, 1);

29072
          }

29073


29074
          /* port 5 */

29075
          {

29076
            real32_T const **sfcnUPtrs = (real32_T const **)

29077
              malloc(1 * sizeof(real32_T *));

29078
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29079
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29080
              ssGetLocalBlockIO(rts))->Switch_jf;

29081
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

29082
            _ssSetInputPortNumDimensions(childS, 5, 1);

29083
            ssSetInputPortWidth(childS, 5, 1);

29084
          }

29085


29086
          /* port 6 */

29087
          {

29088
            real32_T const **sfcnUPtrs = (real32_T const **)

29089
              malloc(1 * sizeof(real32_T *));

29090
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29091
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29092
              ssGetLocalBlockIO(rts))->GeneratedSFunction_pk;

29093
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

29094
            _ssSetInputPortNumDimensions(childS, 6, 1);

29095
            ssSetInputPortWidth(childS, 6, 1);

29096
          }

29097
        }

29098


29099
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

29100
          RegNumOutputPorts);

29101
        ssSetRegNumOutputPortsFcnArg(childS,childS);

29102


29103
        /* outputs */

29104
        {

29105
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

29106
            calloc(1, sizeof(struct _ssPortOutputs));

29107
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

29108
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

29109
          _ssSetNumOutputPorts(childS, 1);

29110


29111
          /* port 0 */

29112
          {

29113
            _ssSetOutputPortNumDimensions(childS, 0, 1);

29114
            ssSetOutputPortWidth(childS, 0, 1);

29115
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

29116
              ssGetLocalBlockIO(rts))->MinMax));

29117
          }

29118
        }

29119


29120
        /* path info */

29121
        _ssSetModelName(childS, "LeadLagFilter_sf");

29122
        _ssSetPath(childS,

29123
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Lead lag1/Generated S-Function2");

29124
        if (ssGetRTModel(rts) == (NULL)) {

29125
          _ssSetParentSS(childS, rts);

29126
          _ssSetRootSS(childS, ssGetRootSS(rts));

29127
        } else {

29128
          ssSetRTModel(childS,ssGetRTModel(rts));

29129
          _ssSetParentSS(childS, (NULL));

29130
          _ssSetRootSS(childS, childS);

29131
        }

29132


29133
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

29134


29135
        /* work vectors */

29136
        {

29137
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

29138
            (4 * sizeof(struct _ssDWorkRecord));

29139
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

29140
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

29141
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

29142
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

29143
          ssSetSFcnDWork(childS, dWorkRecord);

29144
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

29145
          _ssSetNumDWork(childS, 4);

29146


29147
          /* DWORK0 */

29148
          ssSetDWorkWidth(childS, 0, 1);

29149
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

29150
          ssSetDWorkComplexSignal(childS, 0, 0);

29151
          ssSetDWorkUsedAsDState(childS, 0, 1);

29152
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 227))[0]);

29153


29154
          /* DWORK1 */

29155
          ssSetDWorkWidth(childS, 1, 1);

29156
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

29157
          ssSetDWorkComplexSignal(childS, 1, 0);

29158
          ssSetDWorkUsedAsDState(childS, 1, 1);

29159
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 228))[0]);

29160


29161
          /* DWORK2 */

29162
          ssSetDWorkWidth(childS, 2, 1);

29163
          ssSetDWorkDataType(childS, 2,SS_INT8);

29164
          ssSetDWorkComplexSignal(childS, 2, 0);

29165
          ssSetDWorkUsedAsDState(childS, 2, 1);

29166
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 454))[0]);

29167


29168
          /* DWORK3 */

29169
          ssSetDWorkWidth(childS, 3, 1);

29170
          ssSetDWorkDataType(childS, 3,SS_INT8);

29171
          ssSetDWorkComplexSignal(childS, 3, 0);

29172
          ssSetDWorkUsedAsDState(childS, 3, 1);

29173
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 455))[0]);

29174
        }

29175


29176
        (childS)->regDataType.arg1 = ((void *)(childS));

29177
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

29178
          FcnSetErrorStatus);

29179
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

29180
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

29181
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

29182
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

29183


29184
        /* registration */

29185
#if defined(MATLAB_MEX_FILE)

29186


29187
        {

29188
          int_T i;

29189
          mxArray *plhs[1];

29190
          mxArray *prhs[4];

29191
          double *pr;

29192
          volatile int_T *intS = (int_T *)&childS;

29193
          int_T addrlen = sizeof(SimStruct *);

29194
          int_T m = addrlen/sizeof(int_T) + 1;

29195
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

29196
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

29197
          pr = mxGetPr(prhs[1]);

29198
          for (i = 0; i < m - 1; i++) {

29199
            pr[i] = (double)intS[i];

29200
          }

29201


29202
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

29203
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

29204
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

29205


29206
          /* Reset port dimensions info functions because the S-function

29207
           * and accelerator mex-files explicitly set their dimensions,

29208
           * i.e., they are not dynamically sized. For this case, the

29209
           * mex-file is responsible for the dimensions info memory

29210
           * and Simulink should not free it. This is achieved by

29211
           * setting the following two methods to NULL.

29212
           */

29213
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

29214
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

29215


29216
          /*

29217
           * Setup function pointers and call mdlInitializeSizes via

29218
           * simulink.c

29219
           */

29220
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

29221
          mxDestroyArray(plhs[0]);

29222
          mxDestroyArray(prhs[0]);

29223
          mxDestroyArray(prhs[1]);

29224
          mxDestroyArray(prhs[2]);

29225
          mxDestroyArray(prhs[3]);

29226
        }

29227


29228
#else

29229


29230
        {

29231
          LeadLagFilter_sf(childS);

29232
          sfcnInitializeSizes(childS);

29233
        }

29234


29235
#endif

29236


29237
        sfcnInitializeSampleTimes(childS);

29238


29239
        /* adjust sample time */

29240
        ssSetSampleTime(childS, 0, 0.0);

29241
        ssSetOffsetTime(childS, 0, 0.0);

29242
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

29243


29244
        /* set compiled values of dynamic vector attributes */

29245
        ssSetNumNonsampledZCs(childS, 0);

29246


29247
        /* Update connectivity flags for each port */

29248
        _ssSetInputPortConnected(childS, 0, 1);

29249
        _ssSetInputPortConnected(childS, 1, 1);

29250
        _ssSetInputPortConnected(childS, 2, 1);

29251
        _ssSetInputPortConnected(childS, 3, 1);

29252
        _ssSetInputPortConnected(childS, 4, 1);

29253
        _ssSetInputPortConnected(childS, 5, 1);

29254
        _ssSetInputPortConnected(childS, 6, 1);

29255
        _ssSetOutputPortConnected(childS, 0, 1);

29256
        _ssSetOutputPortBeingMerged(childS, 0, 0);

29257


29258
        /* Update the BufferDstPort flags for each input port */

29259
        _ssSetInputPortBufferDstPort(childS, 0, -1);

29260
        _ssSetInputPortBufferDstPort(childS, 1, -1);

29261
        _ssSetInputPortBufferDstPort(childS, 2, -1);

29262
        _ssSetInputPortBufferDstPort(childS, 3, -1);

29263
        _ssSetInputPortBufferDstPort(childS, 4, -1);

29264
        _ssSetInputPortBufferDstPort(childS, 5, -1);

29265
        _ssSetInputPortBufferDstPort(childS, 6, -1);

29266
      }

29267


29268
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S200>/Generated S-Function4 (LagFilter_sf) */

29269
      {

29270
        SimStruct *childS = ssGetSFunction(rts, 111);

29271


29272
        /* timing info */

29273
        time_T *sfcnPeriod;

29274
        time_T *sfcnOffset;

29275
        int_T *sfcnTsMap;

29276
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

29277
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

29278
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

29279
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

29280
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

29281
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

29282
        (void) memset((void*)sfcnPeriod, 0,

29283
                      sizeof(time_T)*1);

29284
        (void) memset((void*)sfcnOffset, 0,

29285
                      sizeof(time_T)*1);

29286
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

29287
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

29288
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

29289


29290
        /* Set up the mdlInfo pointer */

29291
# ifdef USE_RTMODEL

29292


29293
        {

29294
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

29295
              struct _ssBlkInfo2));

29296
          ss_VALIDATE_MEMORY(rts,blkInfo2);

29297
          ssSetBlkInfo2Ptr(childS, blkInfo2);

29298
        }

29299


29300
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

29301


29302
# else

29303


29304
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

29305


29306
# endif                                /* USE_RTMODEL */

29307


29308
        /* Allocate memory of model methods 2 */

29309
        {

29310
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

29311
            malloc(sizeof(struct _ssSFcnModelMethods2));

29312
          ss_VALIDATE_MEMORY(rts,methods2);

29313
          ssSetModelMethods2(childS, methods2);

29314
        }

29315


29316
        /* Allocate memory of model methods 3 */

29317
        {

29318
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

29319
            malloc(sizeof(struct _ssSFcnModelMethods3));

29320
          ss_VALIDATE_MEMORY(rts,methods3);

29321
          ssSetModelMethods3(childS, methods3);

29322
        }

29323


29324
        /* Allocate memory for states auxilliary information */

29325
        {

29326
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

29327
            (sizeof(struct _ssStatesInfo2));

29328
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

29329
            malloc(sizeof(ssPeriodicStatesInfo));

29330
          ss_VALIDATE_MEMORY(rts,statesInfo2);

29331
          ssSetStatesInfo2(childS, statesInfo2);

29332
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

29333
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

29334
        }

29335


29336
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

29337
          RegNumInputPorts);

29338
        ssSetRegNumInputPortsFcnArg(childS,childS);

29339


29340
        /* inputs */

29341
        {

29342
          struct _ssPortInputs *inputPortInfo =

29343
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

29344
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

29345
          _ssSetNumInputPorts(childS, 6);

29346
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

29347


29348
          /* port 0 */

29349
          {

29350
            real32_T const **sfcnUPtrs = (real32_T const **)

29351
              malloc(1 * sizeof(real32_T *));

29352
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29353
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29354
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

29355
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

29356
            _ssSetInputPortNumDimensions(childS, 0, 1);

29357
            ssSetInputPortWidth(childS, 0, 1);

29358
          }

29359


29360
          /* port 1 */

29361
          {

29362
            int8_T const **sfcnUPtrs = (int8_T const **)

29363
              malloc(1 * sizeof(int8_T *));

29364
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29365
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

29366
              ssGetLocalBlockIO(rts))->DataTypeConversion2_j;

29367
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

29368
            _ssSetInputPortNumDimensions(childS, 1, 1);

29369
            ssSetInputPortWidth(childS, 1, 1);

29370
          }

29371


29372
          /* port 2 */

29373
          {

29374
            real32_T const **sfcnUPtrs = (real32_T const **)

29375
              malloc(1 * sizeof(real32_T *));

29376
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29377
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;

29378
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

29379
            _ssSetInputPortNumDimensions(childS, 2, 1);

29380
            ssSetInputPortWidth(childS, 2, 1);

29381
          }

29382


29383
          /* port 3 */

29384
          {

29385
            real32_T const **sfcnUPtrs = (real32_T const **)

29386
              malloc(1 * sizeof(real32_T *));

29387
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29388
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29389
              ssGetLocalBlockIO(rts))->Switch_jf;

29390
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

29391
            _ssSetInputPortNumDimensions(childS, 3, 1);

29392
            ssSetInputPortWidth(childS, 3, 1);

29393
          }

29394


29395
          /* port 4 */

29396
          {

29397
            real32_T const **sfcnUPtrs = (real32_T const **)

29398
              malloc(1 * sizeof(real32_T *));

29399
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29400
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29401
              ssGetLocalBlockIO(rts))->Switch_jf;

29402
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

29403
            _ssSetInputPortNumDimensions(childS, 4, 1);

29404
            ssSetInputPortWidth(childS, 4, 1);

29405
          }

29406


29407
          /* port 5 */

29408
          {

29409
            real32_T const **sfcnUPtrs = (real32_T const **)

29410
              malloc(1 * sizeof(real32_T *));

29411
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29412
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29413
              ssGetLocalBlockIO(rts))->Sum1_k;

29414
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

29415
            _ssSetInputPortNumDimensions(childS, 5, 1);

29416
            ssSetInputPortWidth(childS, 5, 1);

29417
          }

29418
        }

29419


29420
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

29421
          RegNumOutputPorts);

29422
        ssSetRegNumOutputPortsFcnArg(childS,childS);

29423


29424
        /* outputs */

29425
        {

29426
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

29427
            calloc(1, sizeof(struct _ssPortOutputs));

29428
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

29429
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

29430
          _ssSetNumOutputPorts(childS, 1);

29431


29432
          /* port 0 */

29433
          {

29434
            _ssSetOutputPortNumDimensions(childS, 0, 1);

29435
            ssSetOutputPortWidth(childS, 0, 1);

29436
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

29437
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_j));

29438
          }

29439
        }

29440


29441
        /* path info */

29442
        _ssSetModelName(childS, "LagFilter_sf");

29443
        _ssSetPath(childS,

29444
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/ lag filter/Generated S-Function4");

29445
        if (ssGetRTModel(rts) == (NULL)) {

29446
          _ssSetParentSS(childS, rts);

29447
          _ssSetRootSS(childS, ssGetRootSS(rts));

29448
        } else {

29449
          ssSetRTModel(childS,ssGetRTModel(rts));

29450
          _ssSetParentSS(childS, (NULL));

29451
          _ssSetRootSS(childS, childS);

29452
        }

29453


29454
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

29455


29456
        /* work vectors */

29457
        {

29458
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

29459
            (4 * sizeof(struct _ssDWorkRecord));

29460
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

29461
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

29462
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

29463
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

29464
          ssSetSFcnDWork(childS, dWorkRecord);

29465
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

29466
          _ssSetNumDWork(childS, 4);

29467


29468
          /* DWORK0 */

29469
          ssSetDWorkWidth(childS, 0, 1);

29470
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

29471
          ssSetDWorkComplexSignal(childS, 0, 0);

29472
          ssSetDWorkUsedAsDState(childS, 0, 1);

29473
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 229))[0]);

29474


29475
          /* DWORK1 */

29476
          ssSetDWorkWidth(childS, 1, 1);

29477
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

29478
          ssSetDWorkComplexSignal(childS, 1, 0);

29479
          ssSetDWorkUsedAsDState(childS, 1, 1);

29480
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 230))[0]);

29481


29482
          /* DWORK2 */

29483
          ssSetDWorkWidth(childS, 2, 1);

29484
          ssSetDWorkDataType(childS, 2,SS_INT8);

29485
          ssSetDWorkComplexSignal(childS, 2, 0);

29486
          ssSetDWorkUsedAsDState(childS, 2, 1);

29487
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 456))[0]);

29488


29489
          /* DWORK3 */

29490
          ssSetDWorkWidth(childS, 3, 1);

29491
          ssSetDWorkDataType(childS, 3,SS_INT8);

29492
          ssSetDWorkComplexSignal(childS, 3, 0);

29493
          ssSetDWorkUsedAsDState(childS, 3, 1);

29494
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 457))[0]);

29495
        }

29496


29497
        (childS)->regDataType.arg1 = ((void *)(childS));

29498
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

29499
          FcnSetErrorStatus);

29500
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

29501
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

29502
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

29503
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

29504


29505
        /* registration */

29506
#if defined(MATLAB_MEX_FILE)

29507


29508
        {

29509
          int_T i;

29510
          mxArray *plhs[1];

29511
          mxArray *prhs[4];

29512
          double *pr;

29513
          volatile int_T *intS = (int_T *)&childS;

29514
          int_T addrlen = sizeof(SimStruct *);

29515
          int_T m = addrlen/sizeof(int_T) + 1;

29516
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

29517
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

29518
          pr = mxGetPr(prhs[1]);

29519
          for (i = 0; i < m - 1; i++) {

29520
            pr[i] = (double)intS[i];

29521
          }

29522


29523
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

29524
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

29525
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

29526


29527
          /* Reset port dimensions info functions because the S-function

29528
           * and accelerator mex-files explicitly set their dimensions,

29529
           * i.e., they are not dynamically sized. For this case, the

29530
           * mex-file is responsible for the dimensions info memory

29531
           * and Simulink should not free it. This is achieved by

29532
           * setting the following two methods to NULL.

29533
           */

29534
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

29535
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

29536


29537
          /*

29538
           * Setup function pointers and call mdlInitializeSizes via

29539
           * simulink.c

29540
           */

29541
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

29542
          mxDestroyArray(plhs[0]);

29543
          mxDestroyArray(prhs[0]);

29544
          mxDestroyArray(prhs[1]);

29545
          mxDestroyArray(prhs[2]);

29546
          mxDestroyArray(prhs[3]);

29547
        }

29548


29549
#else

29550


29551
        {

29552
          LagFilter_sf(childS);

29553
          sfcnInitializeSizes(childS);

29554
        }

29555


29556
#endif

29557


29558
        sfcnInitializeSampleTimes(childS);

29559


29560
        /* adjust sample time */

29561
        ssSetSampleTime(childS, 0, 0.0);

29562
        ssSetOffsetTime(childS, 0, 0.0);

29563
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

29564


29565
        /* set compiled values of dynamic vector attributes */

29566
        ssSetNumNonsampledZCs(childS, 0);

29567


29568
        /* Update connectivity flags for each port */

29569
        _ssSetInputPortConnected(childS, 0, 1);

29570
        _ssSetInputPortConnected(childS, 1, 1);

29571
        _ssSetInputPortConnected(childS, 2, 1);

29572
        _ssSetInputPortConnected(childS, 3, 1);

29573
        _ssSetInputPortConnected(childS, 4, 1);

29574
        _ssSetInputPortConnected(childS, 5, 1);

29575
        _ssSetOutputPortConnected(childS, 0, 1);

29576
        _ssSetOutputPortBeingMerged(childS, 0, 0);

29577


29578
        /* Update the BufferDstPort flags for each input port */

29579
        _ssSetInputPortBufferDstPort(childS, 0, -1);

29580
        _ssSetInputPortBufferDstPort(childS, 1, -1);

29581
        _ssSetInputPortBufferDstPort(childS, 2, -1);

29582
        _ssSetInputPortBufferDstPort(childS, 3, -1);

29583
        _ssSetInputPortBufferDstPort(childS, 4, -1);

29584
        _ssSetInputPortBufferDstPort(childS, 5, -1);

29585
      }

29586


29587
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S69>/Generated S-Function4 (LagFilter_sf) */

29588
      {

29589
        SimStruct *childS = ssGetSFunction(rts, 112);

29590


29591
        /* timing info */

29592
        time_T *sfcnPeriod;

29593
        time_T *sfcnOffset;

29594
        int_T *sfcnTsMap;

29595
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

29596
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

29597
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

29598
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

29599
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

29600
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

29601
        (void) memset((void*)sfcnPeriod, 0,

29602
                      sizeof(time_T)*1);

29603
        (void) memset((void*)sfcnOffset, 0,

29604
                      sizeof(time_T)*1);

29605
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

29606
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

29607
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

29608


29609
        /* Set up the mdlInfo pointer */

29610
# ifdef USE_RTMODEL

29611


29612
        {

29613
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

29614
              struct _ssBlkInfo2));

29615
          ss_VALIDATE_MEMORY(rts,blkInfo2);

29616
          ssSetBlkInfo2Ptr(childS, blkInfo2);

29617
        }

29618


29619
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

29620


29621
# else

29622


29623
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

29624


29625
# endif                                /* USE_RTMODEL */

29626


29627
        /* Allocate memory of model methods 2 */

29628
        {

29629
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

29630
            malloc(sizeof(struct _ssSFcnModelMethods2));

29631
          ss_VALIDATE_MEMORY(rts,methods2);

29632
          ssSetModelMethods2(childS, methods2);

29633
        }

29634


29635
        /* Allocate memory of model methods 3 */

29636
        {

29637
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

29638
            malloc(sizeof(struct _ssSFcnModelMethods3));

29639
          ss_VALIDATE_MEMORY(rts,methods3);

29640
          ssSetModelMethods3(childS, methods3);

29641
        }

29642


29643
        /* Allocate memory for states auxilliary information */

29644
        {

29645
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

29646
            (sizeof(struct _ssStatesInfo2));

29647
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

29648
            malloc(sizeof(ssPeriodicStatesInfo));

29649
          ss_VALIDATE_MEMORY(rts,statesInfo2);

29650
          ssSetStatesInfo2(childS, statesInfo2);

29651
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

29652
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

29653
        }

29654


29655
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

29656
          RegNumInputPorts);

29657
        ssSetRegNumInputPortsFcnArg(childS,childS);

29658


29659
        /* inputs */

29660
        {

29661
          struct _ssPortInputs *inputPortInfo =

29662
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

29663
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

29664
          _ssSetNumInputPorts(childS, 6);

29665
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

29666


29667
          /* port 0 */

29668
          {

29669
            real32_T const **sfcnUPtrs = (real32_T const **)

29670
              malloc(1 * sizeof(real32_T *));

29671
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29672
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29673
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

29674
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

29675
            _ssSetInputPortNumDimensions(childS, 0, 1);

29676
            ssSetInputPortWidth(childS, 0, 1);

29677
          }

29678


29679
          /* port 1 */

29680
          {

29681
            int8_T const **sfcnUPtrs = (int8_T const **)

29682
              malloc(1 * sizeof(int8_T *));

29683
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29684
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

29685
              ssGetLocalBlockIO(rts))->DataTypeConversion_p;

29686
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

29687
            _ssSetInputPortNumDimensions(childS, 1, 1);

29688
            ssSetInputPortWidth(childS, 1, 1);

29689
          }

29690


29691
          /* port 2 */

29692
          {

29693
            real32_T const **sfcnUPtrs = (real32_T const **)

29694
              malloc(1 * sizeof(real32_T *));

29695
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29696
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

29697
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

29698
            _ssSetInputPortNumDimensions(childS, 2, 1);

29699
            ssSetInputPortWidth(childS, 2, 1);

29700
          }

29701


29702
          /* port 3 */

29703
          {

29704
            real32_T const **sfcnUPtrs = (real32_T const **)

29705
              malloc(1 * sizeof(real32_T *));

29706
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29707
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29708
              ssGetLocalBlockIO(rts))->Switch_fz;

29709
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

29710
            _ssSetInputPortNumDimensions(childS, 3, 1);

29711
            ssSetInputPortWidth(childS, 3, 1);

29712
          }

29713


29714
          /* port 4 */

29715
          {

29716
            real32_T const **sfcnUPtrs = (real32_T const **)

29717
              malloc(1 * sizeof(real32_T *));

29718
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29719
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29720
              ssGetLocalBlockIO(rts))->Switch_fz;

29721
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

29722
            _ssSetInputPortNumDimensions(childS, 4, 1);

29723
            ssSetInputPortWidth(childS, 4, 1);

29724
          }

29725


29726
          /* port 5 */

29727
          {

29728
            real32_T const **sfcnUPtrs = (real32_T const **)

29729
              malloc(1 * sizeof(real32_T *));

29730
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29731
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

29732
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

29733
            _ssSetInputPortNumDimensions(childS, 5, 1);

29734
            ssSetInputPortWidth(childS, 5, 1);

29735
          }

29736
        }

29737


29738
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

29739
          RegNumOutputPorts);

29740
        ssSetRegNumOutputPortsFcnArg(childS,childS);

29741


29742
        /* outputs */

29743
        {

29744
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

29745
            calloc(1, sizeof(struct _ssPortOutputs));

29746
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

29747
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

29748
          _ssSetNumOutputPorts(childS, 1);

29749


29750
          /* port 0 */

29751
          {

29752
            _ssSetOutputPortNumDimensions(childS, 0, 1);

29753
            ssSetOutputPortWidth(childS, 0, 1);

29754
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

29755
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_pd));

29756
          }

29757
        }

29758


29759
        /* path info */

29760
        _ssSetModelName(childS, "LagFilter_sf");

29761
        _ssSetPath(childS,

29762
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/ lag filter/Generated S-Function4");

29763
        if (ssGetRTModel(rts) == (NULL)) {

29764
          _ssSetParentSS(childS, rts);

29765
          _ssSetRootSS(childS, ssGetRootSS(rts));

29766
        } else {

29767
          ssSetRTModel(childS,ssGetRTModel(rts));

29768
          _ssSetParentSS(childS, (NULL));

29769
          _ssSetRootSS(childS, childS);

29770
        }

29771


29772
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

29773


29774
        /* work vectors */

29775
        {

29776
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

29777
            (4 * sizeof(struct _ssDWorkRecord));

29778
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

29779
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

29780
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

29781
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

29782
          ssSetSFcnDWork(childS, dWorkRecord);

29783
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

29784
          _ssSetNumDWork(childS, 4);

29785


29786
          /* DWORK0 */

29787
          ssSetDWorkWidth(childS, 0, 1);

29788
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

29789
          ssSetDWorkComplexSignal(childS, 0, 0);

29790
          ssSetDWorkUsedAsDState(childS, 0, 1);

29791
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 232))[0]);

29792


29793
          /* DWORK1 */

29794
          ssSetDWorkWidth(childS, 1, 1);

29795
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

29796
          ssSetDWorkComplexSignal(childS, 1, 0);

29797
          ssSetDWorkUsedAsDState(childS, 1, 1);

29798
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 233))[0]);

29799


29800
          /* DWORK2 */

29801
          ssSetDWorkWidth(childS, 2, 1);

29802
          ssSetDWorkDataType(childS, 2,SS_INT8);

29803
          ssSetDWorkComplexSignal(childS, 2, 0);

29804
          ssSetDWorkUsedAsDState(childS, 2, 1);

29805
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 459))[0]);

29806


29807
          /* DWORK3 */

29808
          ssSetDWorkWidth(childS, 3, 1);

29809
          ssSetDWorkDataType(childS, 3,SS_INT8);

29810
          ssSetDWorkComplexSignal(childS, 3, 0);

29811
          ssSetDWorkUsedAsDState(childS, 3, 1);

29812
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 460))[0]);

29813
        }

29814


29815
        (childS)->regDataType.arg1 = ((void *)(childS));

29816
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

29817
          FcnSetErrorStatus);

29818
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

29819
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

29820
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

29821
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

29822


29823
        /* registration */

29824
#if defined(MATLAB_MEX_FILE)

29825


29826
        {

29827
          int_T i;

29828
          mxArray *plhs[1];

29829
          mxArray *prhs[4];

29830
          double *pr;

29831
          volatile int_T *intS = (int_T *)&childS;

29832
          int_T addrlen = sizeof(SimStruct *);

29833
          int_T m = addrlen/sizeof(int_T) + 1;

29834
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

29835
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

29836
          pr = mxGetPr(prhs[1]);

29837
          for (i = 0; i < m - 1; i++) {

29838
            pr[i] = (double)intS[i];

29839
          }

29840


29841
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

29842
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

29843
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

29844


29845
          /* Reset port dimensions info functions because the S-function

29846
           * and accelerator mex-files explicitly set their dimensions,

29847
           * i.e., they are not dynamically sized. For this case, the

29848
           * mex-file is responsible for the dimensions info memory

29849
           * and Simulink should not free it. This is achieved by

29850
           * setting the following two methods to NULL.

29851
           */

29852
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

29853
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

29854


29855
          /*

29856
           * Setup function pointers and call mdlInitializeSizes via

29857
           * simulink.c

29858
           */

29859
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

29860
          mxDestroyArray(plhs[0]);

29861
          mxDestroyArray(prhs[0]);

29862
          mxDestroyArray(prhs[1]);

29863
          mxDestroyArray(prhs[2]);

29864
          mxDestroyArray(prhs[3]);

29865
        }

29866


29867
#else

29868


29869
        {

29870
          LagFilter_sf(childS);

29871
          sfcnInitializeSizes(childS);

29872
        }

29873


29874
#endif

29875


29876
        sfcnInitializeSampleTimes(childS);

29877


29878
        /* adjust sample time */

29879
        ssSetSampleTime(childS, 0, 0.0);

29880
        ssSetOffsetTime(childS, 0, 0.0);

29881
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

29882


29883
        /* set compiled values of dynamic vector attributes */

29884
        ssSetNumNonsampledZCs(childS, 0);

29885


29886
        /* Update connectivity flags for each port */

29887
        _ssSetInputPortConnected(childS, 0, 1);

29888
        _ssSetInputPortConnected(childS, 1, 1);

29889
        _ssSetInputPortConnected(childS, 2, 1);

29890
        _ssSetInputPortConnected(childS, 3, 1);

29891
        _ssSetInputPortConnected(childS, 4, 1);

29892
        _ssSetInputPortConnected(childS, 5, 1);

29893
        _ssSetOutputPortConnected(childS, 0, 1);

29894
        _ssSetOutputPortBeingMerged(childS, 0, 0);

29895


29896
        /* Update the BufferDstPort flags for each input port */

29897
        _ssSetInputPortBufferDstPort(childS, 0, -1);

29898
        _ssSetInputPortBufferDstPort(childS, 1, -1);

29899
        _ssSetInputPortBufferDstPort(childS, 2, -1);

29900
        _ssSetInputPortBufferDstPort(childS, 3, -1);

29901
        _ssSetInputPortBufferDstPort(childS, 4, -1);

29902
        _ssSetInputPortBufferDstPort(childS, 5, -1);

29903
      }

29904


29905
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S70>/Generated S-Function4 (LagFilter_sf) */

29906
      {

29907
        SimStruct *childS = ssGetSFunction(rts, 113);

29908


29909
        /* timing info */

29910
        time_T *sfcnPeriod;

29911
        time_T *sfcnOffset;

29912
        int_T *sfcnTsMap;

29913
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

29914
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

29915
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

29916
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

29917
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

29918
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

29919
        (void) memset((void*)sfcnPeriod, 0,

29920
                      sizeof(time_T)*1);

29921
        (void) memset((void*)sfcnOffset, 0,

29922
                      sizeof(time_T)*1);

29923
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

29924
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

29925
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

29926


29927
        /* Set up the mdlInfo pointer */

29928
# ifdef USE_RTMODEL

29929


29930
        {

29931
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

29932
              struct _ssBlkInfo2));

29933
          ss_VALIDATE_MEMORY(rts,blkInfo2);

29934
          ssSetBlkInfo2Ptr(childS, blkInfo2);

29935
        }

29936


29937
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

29938


29939
# else

29940


29941
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

29942


29943
# endif                                /* USE_RTMODEL */

29944


29945
        /* Allocate memory of model methods 2 */

29946
        {

29947
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

29948
            malloc(sizeof(struct _ssSFcnModelMethods2));

29949
          ss_VALIDATE_MEMORY(rts,methods2);

29950
          ssSetModelMethods2(childS, methods2);

29951
        }

29952


29953
        /* Allocate memory of model methods 3 */

29954
        {

29955
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

29956
            malloc(sizeof(struct _ssSFcnModelMethods3));

29957
          ss_VALIDATE_MEMORY(rts,methods3);

29958
          ssSetModelMethods3(childS, methods3);

29959
        }

29960


29961
        /* Allocate memory for states auxilliary information */

29962
        {

29963
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

29964
            (sizeof(struct _ssStatesInfo2));

29965
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

29966
            malloc(sizeof(ssPeriodicStatesInfo));

29967
          ss_VALIDATE_MEMORY(rts,statesInfo2);

29968
          ssSetStatesInfo2(childS, statesInfo2);

29969
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

29970
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

29971
        }

29972


29973
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

29974
          RegNumInputPorts);

29975
        ssSetRegNumInputPortsFcnArg(childS,childS);

29976


29977
        /* inputs */

29978
        {

29979
          struct _ssPortInputs *inputPortInfo =

29980
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

29981
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

29982
          _ssSetNumInputPorts(childS, 6);

29983
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

29984


29985
          /* port 0 */

29986
          {

29987
            real32_T const **sfcnUPtrs = (real32_T const **)

29988
              malloc(1 * sizeof(real32_T *));

29989
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

29990
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

29991
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

29992
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

29993
            _ssSetInputPortNumDimensions(childS, 0, 1);

29994
            ssSetInputPortWidth(childS, 0, 1);

29995
          }

29996


29997
          /* port 1 */

29998
          {

29999
            int8_T const **sfcnUPtrs = (int8_T const **)

30000
              malloc(1 * sizeof(int8_T *));

30001
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30002
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

30003
              ssGetLocalBlockIO(rts))->DataTypeConversion2_b;

30004
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

30005
            _ssSetInputPortNumDimensions(childS, 1, 1);

30006
            ssSetInputPortWidth(childS, 1, 1);

30007
          }

30008


30009
          /* port 2 */

30010
          {

30011
            real32_T const **sfcnUPtrs = (real32_T const **)

30012
              malloc(1 * sizeof(real32_T *));

30013
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30014
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

30015
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

30016
            _ssSetInputPortNumDimensions(childS, 2, 1);

30017
            ssSetInputPortWidth(childS, 2, 1);

30018
          }

30019


30020
          /* port 3 */

30021
          {

30022
            real32_T const **sfcnUPtrs = (real32_T const **)

30023
              malloc(1 * sizeof(real32_T *));

30024
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30025
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

30026
              ssGetLocalBlockIO(rts))->Switch_fz;

30027
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

30028
            _ssSetInputPortNumDimensions(childS, 3, 1);

30029
            ssSetInputPortWidth(childS, 3, 1);

30030
          }

30031


30032
          /* port 4 */

30033
          {

30034
            real32_T const **sfcnUPtrs = (real32_T const **)

30035
              malloc(1 * sizeof(real32_T *));

30036
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30037
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

30038
              ssGetLocalBlockIO(rts))->Switch_fz;

30039
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

30040
            _ssSetInputPortNumDimensions(childS, 4, 1);

30041
            ssSetInputPortWidth(childS, 4, 1);

30042
          }

30043


30044
          /* port 5 */

30045
          {

30046
            real32_T const **sfcnUPtrs = (real32_T const **)

30047
              malloc(1 * sizeof(real32_T *));

30048
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30049
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

30050
              ssGetLocalBlockIO(rts))->Gain_k;

30051
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

30052
            _ssSetInputPortNumDimensions(childS, 5, 1);

30053
            ssSetInputPortWidth(childS, 5, 1);

30054
          }

30055
        }

30056


30057
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

30058
          RegNumOutputPorts);

30059
        ssSetRegNumOutputPortsFcnArg(childS,childS);

30060


30061
        /* outputs */

30062
        {

30063
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

30064
            calloc(1, sizeof(struct _ssPortOutputs));

30065
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

30066
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

30067
          _ssSetNumOutputPorts(childS, 1);

30068


30069
          /* port 0 */

30070
          {

30071
            _ssSetOutputPortNumDimensions(childS, 0, 1);

30072
            ssSetOutputPortWidth(childS, 0, 1);

30073
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

30074
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_h));

30075
          }

30076
        }

30077


30078
        /* path info */

30079
        _ssSetModelName(childS, "LagFilter_sf");

30080
        _ssSetPath(childS,

30081
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/ lag filter1/Generated S-Function4");

30082
        if (ssGetRTModel(rts) == (NULL)) {

30083
          _ssSetParentSS(childS, rts);

30084
          _ssSetRootSS(childS, ssGetRootSS(rts));

30085
        } else {

30086
          ssSetRTModel(childS,ssGetRTModel(rts));

30087
          _ssSetParentSS(childS, (NULL));

30088
          _ssSetRootSS(childS, childS);

30089
        }

30090


30091
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

30092


30093
        /* work vectors */

30094
        {

30095
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

30096
            (4 * sizeof(struct _ssDWorkRecord));

30097
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

30098
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

30099
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

30100
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

30101
          ssSetSFcnDWork(childS, dWorkRecord);

30102
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

30103
          _ssSetNumDWork(childS, 4);

30104


30105
          /* DWORK0 */

30106
          ssSetDWorkWidth(childS, 0, 1);

30107
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

30108
          ssSetDWorkComplexSignal(childS, 0, 0);

30109
          ssSetDWorkUsedAsDState(childS, 0, 1);

30110
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 234))[0]);

30111


30112
          /* DWORK1 */

30113
          ssSetDWorkWidth(childS, 1, 1);

30114
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

30115
          ssSetDWorkComplexSignal(childS, 1, 0);

30116
          ssSetDWorkUsedAsDState(childS, 1, 1);

30117
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 235))[0]);

30118


30119
          /* DWORK2 */

30120
          ssSetDWorkWidth(childS, 2, 1);

30121
          ssSetDWorkDataType(childS, 2,SS_INT8);

30122
          ssSetDWorkComplexSignal(childS, 2, 0);

30123
          ssSetDWorkUsedAsDState(childS, 2, 1);

30124
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 461))[0]);

30125


30126
          /* DWORK3 */

30127
          ssSetDWorkWidth(childS, 3, 1);

30128
          ssSetDWorkDataType(childS, 3,SS_INT8);

30129
          ssSetDWorkComplexSignal(childS, 3, 0);

30130
          ssSetDWorkUsedAsDState(childS, 3, 1);

30131
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 462))[0]);

30132
        }

30133


30134
        (childS)->regDataType.arg1 = ((void *)(childS));

30135
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

30136
          FcnSetErrorStatus);

30137
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

30138
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

30139
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

30140
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

30141


30142
        /* registration */

30143
#if defined(MATLAB_MEX_FILE)

30144


30145
        {

30146
          int_T i;

30147
          mxArray *plhs[1];

30148
          mxArray *prhs[4];

30149
          double *pr;

30150
          volatile int_T *intS = (int_T *)&childS;

30151
          int_T addrlen = sizeof(SimStruct *);

30152
          int_T m = addrlen/sizeof(int_T) + 1;

30153
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

30154
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

30155
          pr = mxGetPr(prhs[1]);

30156
          for (i = 0; i < m - 1; i++) {

30157
            pr[i] = (double)intS[i];

30158
          }

30159


30160
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

30161
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

30162
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

30163


30164
          /* Reset port dimensions info functions because the S-function

30165
           * and accelerator mex-files explicitly set their dimensions,

30166
           * i.e., they are not dynamically sized. For this case, the

30167
           * mex-file is responsible for the dimensions info memory

30168
           * and Simulink should not free it. This is achieved by

30169
           * setting the following two methods to NULL.

30170
           */

30171
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

30172
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

30173


30174
          /*

30175
           * Setup function pointers and call mdlInitializeSizes via

30176
           * simulink.c

30177
           */

30178
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

30179
          mxDestroyArray(plhs[0]);

30180
          mxDestroyArray(prhs[0]);

30181
          mxDestroyArray(prhs[1]);

30182
          mxDestroyArray(prhs[2]);

30183
          mxDestroyArray(prhs[3]);

30184
        }

30185


30186
#else

30187


30188
        {

30189
          LagFilter_sf(childS);

30190
          sfcnInitializeSizes(childS);

30191
        }

30192


30193
#endif

30194


30195
        sfcnInitializeSampleTimes(childS);

30196


30197
        /* adjust sample time */

30198
        ssSetSampleTime(childS, 0, 0.0);

30199
        ssSetOffsetTime(childS, 0, 0.0);

30200
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

30201


30202
        /* set compiled values of dynamic vector attributes */

30203
        ssSetNumNonsampledZCs(childS, 0);

30204


30205
        /* Update connectivity flags for each port */

30206
        _ssSetInputPortConnected(childS, 0, 1);

30207
        _ssSetInputPortConnected(childS, 1, 1);

30208
        _ssSetInputPortConnected(childS, 2, 1);

30209
        _ssSetInputPortConnected(childS, 3, 1);

30210
        _ssSetInputPortConnected(childS, 4, 1);

30211
        _ssSetInputPortConnected(childS, 5, 1);

30212
        _ssSetOutputPortConnected(childS, 0, 1);

30213
        _ssSetOutputPortBeingMerged(childS, 0, 0);

30214


30215
        /* Update the BufferDstPort flags for each input port */

30216
        _ssSetInputPortBufferDstPort(childS, 0, -1);

30217
        _ssSetInputPortBufferDstPort(childS, 1, -1);

30218
        _ssSetInputPortBufferDstPort(childS, 2, -1);

30219
        _ssSetInputPortBufferDstPort(childS, 3, -1);

30220
        _ssSetInputPortBufferDstPort(childS, 4, -1);

30221
        _ssSetInputPortBufferDstPort(childS, 5, -1);

30222
      }

30223


30224
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S77>/Generated S-Function1 (SaturationLimiter_sf) */

30225
      {

30226
        SimStruct *childS = ssGetSFunction(rts, 114);

30227


30228
        /* timing info */

30229
        time_T *sfcnPeriod;

30230
        time_T *sfcnOffset;

30231
        int_T *sfcnTsMap;

30232
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

30233
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

30234
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

30235
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

30236
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

30237
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

30238
        (void) memset((void*)sfcnPeriod, 0,

30239
                      sizeof(time_T)*1);

30240
        (void) memset((void*)sfcnOffset, 0,

30241
                      sizeof(time_T)*1);

30242
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

30243
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

30244
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

30245


30246
        /* Set up the mdlInfo pointer */

30247
# ifdef USE_RTMODEL

30248


30249
        {

30250
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

30251
              struct _ssBlkInfo2));

30252
          ss_VALIDATE_MEMORY(rts,blkInfo2);

30253
          ssSetBlkInfo2Ptr(childS, blkInfo2);

30254
        }

30255


30256
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

30257


30258
# else

30259


30260
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

30261


30262
# endif                                /* USE_RTMODEL */

30263


30264
        /* Allocate memory of model methods 2 */

30265
        {

30266
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

30267
            malloc(sizeof(struct _ssSFcnModelMethods2));

30268
          ss_VALIDATE_MEMORY(rts,methods2);

30269
          ssSetModelMethods2(childS, methods2);

30270
        }

30271


30272
        /* Allocate memory of model methods 3 */

30273
        {

30274
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

30275
            malloc(sizeof(struct _ssSFcnModelMethods3));

30276
          ss_VALIDATE_MEMORY(rts,methods3);

30277
          ssSetModelMethods3(childS, methods3);

30278
        }

30279


30280
        /* Allocate memory for states auxilliary information */

30281
        {

30282
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

30283
            (sizeof(struct _ssStatesInfo2));

30284
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

30285
            malloc(sizeof(ssPeriodicStatesInfo));

30286
          ss_VALIDATE_MEMORY(rts,statesInfo2);

30287
          ssSetStatesInfo2(childS, statesInfo2);

30288
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

30289
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

30290
        }

30291


30292
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

30293
          RegNumInputPorts);

30294
        ssSetRegNumInputPortsFcnArg(childS,childS);

30295


30296
        /* inputs */

30297
        {

30298
          struct _ssPortInputs *inputPortInfo =

30299
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

30300
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

30301
          _ssSetNumInputPorts(childS, 3);

30302
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

30303


30304
          /* port 0 */

30305
          {

30306
            real32_T const **sfcnUPtrs = (real32_T const **)

30307
              malloc(1 * sizeof(real32_T *));

30308
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30309
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

30310
              ssGetLocalBlockIO(rts))->Sum2_b;

30311
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

30312
            _ssSetInputPortNumDimensions(childS, 0, 1);

30313
            ssSetInputPortWidth(childS, 0, 1);

30314
          }

30315


30316
          /* port 1 */

30317
          {

30318
            real32_T const **sfcnUPtrs = (real32_T const **)

30319
              malloc(1 * sizeof(real32_T *));

30320
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30321
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

30322
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

30323
            _ssSetInputPortNumDimensions(childS, 1, 1);

30324
            ssSetInputPortWidth(childS, 1, 1);

30325
          }

30326


30327
          /* port 2 */

30328
          {

30329
            real32_T const **sfcnUPtrs = (real32_T const **)

30330
              malloc(1 * sizeof(real32_T *));

30331
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30332
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;

30333
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

30334
            _ssSetInputPortNumDimensions(childS, 2, 1);

30335
            ssSetInputPortWidth(childS, 2, 1);

30336
          }

30337
        }

30338


30339
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

30340
          RegNumOutputPorts);

30341
        ssSetRegNumOutputPortsFcnArg(childS,childS);

30342


30343
        /* outputs */

30344
        {

30345
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

30346
            calloc(1, sizeof(struct _ssPortOutputs));

30347
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

30348
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

30349
          _ssSetNumOutputPorts(childS, 1);

30350


30351
          /* port 0 */

30352
          {

30353
            _ssSetOutputPortNumDimensions(childS, 0, 1);

30354
            ssSetOutputPortWidth(childS, 0, 1);

30355
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

30356
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_i));

30357
          }

30358
        }

30359


30360
        /* path info */

30361
        _ssSetModelName(childS, "SaturationLimiter_sf");

30362
        _ssSetPath(childS,

30363
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Saturation Limiter3/Generated S-Function1");

30364
        if (ssGetRTModel(rts) == (NULL)) {

30365
          _ssSetParentSS(childS, rts);

30366
          _ssSetRootSS(childS, ssGetRootSS(rts));

30367
        } else {

30368
          ssSetRTModel(childS,ssGetRTModel(rts));

30369
          _ssSetParentSS(childS, (NULL));

30370
          _ssSetRootSS(childS, childS);

30371
        }

30372


30373
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

30374
        (childS)->regDataType.arg1 = ((void *)(childS));

30375
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

30376
          FcnSetErrorStatus);

30377
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

30378
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

30379
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

30380
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

30381


30382
        /* registration */

30383
#if defined(MATLAB_MEX_FILE)

30384


30385
        {

30386
          int_T i;

30387
          mxArray *plhs[1];

30388
          mxArray *prhs[4];

30389
          double *pr;

30390
          volatile int_T *intS = (int_T *)&childS;

30391
          int_T addrlen = sizeof(SimStruct *);

30392
          int_T m = addrlen/sizeof(int_T) + 1;

30393
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

30394
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

30395
          pr = mxGetPr(prhs[1]);

30396
          for (i = 0; i < m - 1; i++) {

30397
            pr[i] = (double)intS[i];

30398
          }

30399


30400
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

30401
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

30402
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

30403


30404
          /* Reset port dimensions info functions because the S-function

30405
           * and accelerator mex-files explicitly set their dimensions,

30406
           * i.e., they are not dynamically sized. For this case, the

30407
           * mex-file is responsible for the dimensions info memory

30408
           * and Simulink should not free it. This is achieved by

30409
           * setting the following two methods to NULL.

30410
           */

30411
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

30412
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

30413


30414
          /*

30415
           * Setup function pointers and call mdlInitializeSizes via

30416
           * simulink.c

30417
           */

30418
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

30419
          mxDestroyArray(plhs[0]);

30420
          mxDestroyArray(prhs[0]);

30421
          mxDestroyArray(prhs[1]);

30422
          mxDestroyArray(prhs[2]);

30423
          mxDestroyArray(prhs[3]);

30424
        }

30425


30426
#else

30427


30428
        {

30429
          SaturationLimiter_sf(childS);

30430
          sfcnInitializeSizes(childS);

30431
        }

30432


30433
#endif

30434


30435
        sfcnInitializeSampleTimes(childS);

30436


30437
        /* adjust sample time */

30438
        ssSetSampleTime(childS, 0, 0.0);

30439
        ssSetOffsetTime(childS, 0, 0.0);

30440
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

30441


30442
        /* set compiled values of dynamic vector attributes */

30443
        ssSetNumNonsampledZCs(childS, 0);

30444


30445
        /* Update connectivity flags for each port */

30446
        _ssSetInputPortConnected(childS, 0, 1);

30447
        _ssSetInputPortConnected(childS, 1, 1);

30448
        _ssSetInputPortConnected(childS, 2, 1);

30449
        _ssSetOutputPortConnected(childS, 0, 1);

30450
        _ssSetOutputPortBeingMerged(childS, 0, 0);

30451


30452
        /* Update the BufferDstPort flags for each input port */

30453
        _ssSetInputPortBufferDstPort(childS, 0, -1);

30454
        _ssSetInputPortBufferDstPort(childS, 1, -1);

30455
        _ssSetInputPortBufferDstPort(childS, 2, -1);

30456
      }

30457


30458
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S79>/Generated S-Function (Gain_sf) */

30459
      {

30460
        SimStruct *childS = ssGetSFunction(rts, 115);

30461


30462
        /* timing info */

30463
        time_T *sfcnPeriod;

30464
        time_T *sfcnOffset;

30465
        int_T *sfcnTsMap;

30466
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

30467
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

30468
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

30469
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

30470
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

30471
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

30472
        (void) memset((void*)sfcnPeriod, 0,

30473
                      sizeof(time_T)*1);

30474
        (void) memset((void*)sfcnOffset, 0,

30475
                      sizeof(time_T)*1);

30476
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

30477
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

30478
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

30479


30480
        /* Set up the mdlInfo pointer */

30481
# ifdef USE_RTMODEL

30482


30483
        {

30484
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

30485
              struct _ssBlkInfo2));

30486
          ss_VALIDATE_MEMORY(rts,blkInfo2);

30487
          ssSetBlkInfo2Ptr(childS, blkInfo2);

30488
        }

30489


30490
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

30491


30492
# else

30493


30494
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

30495


30496
# endif                                /* USE_RTMODEL */

30497


30498
        /* Allocate memory of model methods 2 */

30499
        {

30500
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

30501
            malloc(sizeof(struct _ssSFcnModelMethods2));

30502
          ss_VALIDATE_MEMORY(rts,methods2);

30503
          ssSetModelMethods2(childS, methods2);

30504
        }

30505


30506
        /* Allocate memory of model methods 3 */

30507
        {

30508
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

30509
            malloc(sizeof(struct _ssSFcnModelMethods3));

30510
          ss_VALIDATE_MEMORY(rts,methods3);

30511
          ssSetModelMethods3(childS, methods3);

30512
        }

30513


30514
        /* Allocate memory for states auxilliary information */

30515
        {

30516
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

30517
            (sizeof(struct _ssStatesInfo2));

30518
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

30519
            malloc(sizeof(ssPeriodicStatesInfo));

30520
          ss_VALIDATE_MEMORY(rts,statesInfo2);

30521
          ssSetStatesInfo2(childS, statesInfo2);

30522
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

30523
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

30524
        }

30525


30526
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

30527
          RegNumInputPorts);

30528
        ssSetRegNumInputPortsFcnArg(childS,childS);

30529


30530
        /* inputs */

30531
        {

30532
          struct _ssPortInputs *inputPortInfo =

30533
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

30534
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

30535
          _ssSetNumInputPorts(childS, 2);

30536
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

30537


30538
          /* port 0 */

30539
          {

30540
            real32_T const **sfcnUPtrs = (real32_T const **)

30541
              malloc(1 * sizeof(real32_T *));

30542
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30543
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

30544
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_i;

30545
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

30546
            _ssSetInputPortNumDimensions(childS, 0, 1);

30547
            ssSetInputPortWidth(childS, 0, 1);

30548
          }

30549


30550
          /* port 1 */

30551
          {

30552
            real32_T const **sfcnUPtrs = (real32_T const **)

30553
              malloc(1 * sizeof(real32_T *));

30554
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30555
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

30556
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

30557
            _ssSetInputPortNumDimensions(childS, 1, 1);

30558
            ssSetInputPortWidth(childS, 1, 1);

30559
          }

30560
        }

30561


30562
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

30563
          RegNumOutputPorts);

30564
        ssSetRegNumOutputPortsFcnArg(childS,childS);

30565


30566
        /* outputs */

30567
        {

30568
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

30569
            calloc(1, sizeof(struct _ssPortOutputs));

30570
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

30571
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

30572
          _ssSetNumOutputPorts(childS, 1);

30573


30574
          /* port 0 */

30575
          {

30576
            _ssSetOutputPortNumDimensions(childS, 0, 1);

30577
            ssSetOutputPortWidth(childS, 0, 1);

30578
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

30579
              ssGetLocalBlockIO(rts))->Saturation2_p));

30580
          }

30581
        }

30582


30583
        /* path info */

30584
        _ssSetModelName(childS, "Gain_sf");

30585
        _ssSetPath(childS,

30586
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/gain3/Generated S-Function");

30587
        if (ssGetRTModel(rts) == (NULL)) {

30588
          _ssSetParentSS(childS, rts);

30589
          _ssSetRootSS(childS, ssGetRootSS(rts));

30590
        } else {

30591
          ssSetRTModel(childS,ssGetRTModel(rts));

30592
          _ssSetParentSS(childS, (NULL));

30593
          _ssSetRootSS(childS, childS);

30594
        }

30595


30596
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

30597
        (childS)->regDataType.arg1 = ((void *)(childS));

30598
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

30599
          FcnSetErrorStatus);

30600
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

30601
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

30602
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

30603
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

30604


30605
        /* registration */

30606
#if defined(MATLAB_MEX_FILE)

30607


30608
        {

30609
          int_T i;

30610
          mxArray *plhs[1];

30611
          mxArray *prhs[4];

30612
          double *pr;

30613
          volatile int_T *intS = (int_T *)&childS;

30614
          int_T addrlen = sizeof(SimStruct *);

30615
          int_T m = addrlen/sizeof(int_T) + 1;

30616
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

30617
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

30618
          pr = mxGetPr(prhs[1]);

30619
          for (i = 0; i < m - 1; i++) {

30620
            pr[i] = (double)intS[i];

30621
          }

30622


30623
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

30624
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

30625
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

30626


30627
          /* Reset port dimensions info functions because the S-function

30628
           * and accelerator mex-files explicitly set their dimensions,

30629
           * i.e., they are not dynamically sized. For this case, the

30630
           * mex-file is responsible for the dimensions info memory

30631
           * and Simulink should not free it. This is achieved by

30632
           * setting the following two methods to NULL.

30633
           */

30634
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

30635
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

30636


30637
          /*

30638
           * Setup function pointers and call mdlInitializeSizes via

30639
           * simulink.c

30640
           */

30641
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

30642
          mxDestroyArray(plhs[0]);

30643
          mxDestroyArray(prhs[0]);

30644
          mxDestroyArray(prhs[1]);

30645
          mxDestroyArray(prhs[2]);

30646
          mxDestroyArray(prhs[3]);

30647
        }

30648


30649
#else

30650


30651
        {

30652
          Gain_sf(childS);

30653
          sfcnInitializeSizes(childS);

30654
        }

30655


30656
#endif

30657


30658
        sfcnInitializeSampleTimes(childS);

30659


30660
        /* adjust sample time */

30661
        ssSetSampleTime(childS, 0, 0.0);

30662
        ssSetOffsetTime(childS, 0, 0.0);

30663
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

30664


30665
        /* set compiled values of dynamic vector attributes */

30666
        ssSetNumNonsampledZCs(childS, 0);

30667


30668
        /* Update connectivity flags for each port */

30669
        _ssSetInputPortConnected(childS, 0, 1);

30670
        _ssSetInputPortConnected(childS, 1, 1);

30671
        _ssSetOutputPortConnected(childS, 0, 1);

30672
        _ssSetOutputPortBeingMerged(childS, 0, 0);

30673


30674
        /* Update the BufferDstPort flags for each input port */

30675
        _ssSetInputPortBufferDstPort(childS, 0, -1);

30676
        _ssSetInputPortBufferDstPort(childS, 1, -1);

30677
      }

30678


30679
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S72>/Generated S-Function6 (Res180_sf) */

30680
      {

30681
        SimStruct *childS = ssGetSFunction(rts, 116);

30682


30683
        /* timing info */

30684
        time_T *sfcnPeriod;

30685
        time_T *sfcnOffset;

30686
        int_T *sfcnTsMap;

30687
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

30688
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

30689
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

30690
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

30691
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

30692
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

30693
        (void) memset((void*)sfcnPeriod, 0,

30694
                      sizeof(time_T)*1);

30695
        (void) memset((void*)sfcnOffset, 0,

30696
                      sizeof(time_T)*1);

30697
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

30698
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

30699
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

30700


30701
        /* Set up the mdlInfo pointer */

30702
# ifdef USE_RTMODEL

30703


30704
        {

30705
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

30706
              struct _ssBlkInfo2));

30707
          ss_VALIDATE_MEMORY(rts,blkInfo2);

30708
          ssSetBlkInfo2Ptr(childS, blkInfo2);

30709
        }

30710


30711
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

30712


30713
# else

30714


30715
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

30716


30717
# endif                                /* USE_RTMODEL */

30718


30719
        /* Allocate memory of model methods 2 */

30720
        {

30721
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

30722
            malloc(sizeof(struct _ssSFcnModelMethods2));

30723
          ss_VALIDATE_MEMORY(rts,methods2);

30724
          ssSetModelMethods2(childS, methods2);

30725
        }

30726


30727
        /* Allocate memory of model methods 3 */

30728
        {

30729
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

30730
            malloc(sizeof(struct _ssSFcnModelMethods3));

30731
          ss_VALIDATE_MEMORY(rts,methods3);

30732
          ssSetModelMethods3(childS, methods3);

30733
        }

30734


30735
        /* Allocate memory for states auxilliary information */

30736
        {

30737
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

30738
            (sizeof(struct _ssStatesInfo2));

30739
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

30740
            malloc(sizeof(ssPeriodicStatesInfo));

30741
          ss_VALIDATE_MEMORY(rts,statesInfo2);

30742
          ssSetStatesInfo2(childS, statesInfo2);

30743
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

30744
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

30745
        }

30746


30747
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

30748
          RegNumInputPorts);

30749
        ssSetRegNumInputPortsFcnArg(childS,childS);

30750


30751
        /* inputs */

30752
        {

30753
          struct _ssPortInputs *inputPortInfo =

30754
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

30755
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

30756
          _ssSetNumInputPorts(childS, 1);

30757
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

30758


30759
          /* port 0 */

30760
          {

30761
            real32_T const **sfcnUPtrs = (real32_T const **)

30762
              malloc(1 * sizeof(real32_T *));

30763
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30764
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

30765
              ssGetLocalBlockIO(rts))->Sum3_ca;

30766
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

30767
            _ssSetInputPortNumDimensions(childS, 0, 1);

30768
            ssSetInputPortWidth(childS, 0, 1);

30769
          }

30770
        }

30771


30772
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

30773
          RegNumOutputPorts);

30774
        ssSetRegNumOutputPortsFcnArg(childS,childS);

30775


30776
        /* outputs */

30777
        {

30778
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

30779
            calloc(1, sizeof(struct _ssPortOutputs));

30780
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

30781
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

30782
          _ssSetNumOutputPorts(childS, 1);

30783


30784
          /* port 0 */

30785
          {

30786
            _ssSetOutputPortNumDimensions(childS, 0, 1);

30787
            ssSetOutputPortWidth(childS, 0, 1);

30788
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

30789
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_j));

30790
          }

30791
        }

30792


30793
        /* path info */

30794
        _ssSetModelName(childS, "Res180_sf");

30795
        _ssSetPath(childS,

30796
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Generated S-Function6");

30797
        if (ssGetRTModel(rts) == (NULL)) {

30798
          _ssSetParentSS(childS, rts);

30799
          _ssSetRootSS(childS, ssGetRootSS(rts));

30800
        } else {

30801
          ssSetRTModel(childS,ssGetRTModel(rts));

30802
          _ssSetParentSS(childS, (NULL));

30803
          _ssSetRootSS(childS, childS);

30804
        }

30805


30806
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

30807
        (childS)->regDataType.arg1 = ((void *)(childS));

30808
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

30809
          FcnSetErrorStatus);

30810
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

30811
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

30812
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

30813
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

30814


30815
        /* registration */

30816
#if defined(MATLAB_MEX_FILE)

30817


30818
        {

30819
          int_T i;

30820
          mxArray *plhs[1];

30821
          mxArray *prhs[4];

30822
          double *pr;

30823
          volatile int_T *intS = (int_T *)&childS;

30824
          int_T addrlen = sizeof(SimStruct *);

30825
          int_T m = addrlen/sizeof(int_T) + 1;

30826
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

30827
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

30828
          pr = mxGetPr(prhs[1]);

30829
          for (i = 0; i < m - 1; i++) {

30830
            pr[i] = (double)intS[i];

30831
          }

30832


30833
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

30834
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

30835
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

30836


30837
          /* Reset port dimensions info functions because the S-function

30838
           * and accelerator mex-files explicitly set their dimensions,

30839
           * i.e., they are not dynamically sized. For this case, the

30840
           * mex-file is responsible for the dimensions info memory

30841
           * and Simulink should not free it. This is achieved by

30842
           * setting the following two methods to NULL.

30843
           */

30844
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

30845
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

30846


30847
          /*

30848
           * Setup function pointers and call mdlInitializeSizes via

30849
           * simulink.c

30850
           */

30851
          mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");

30852
          mxDestroyArray(plhs[0]);

30853
          mxDestroyArray(prhs[0]);

30854
          mxDestroyArray(prhs[1]);

30855
          mxDestroyArray(prhs[2]);

30856
          mxDestroyArray(prhs[3]);

30857
        }

30858


30859
#else

30860


30861
        {

30862
          Res180_sf(childS);

30863
          sfcnInitializeSizes(childS);

30864
        }

30865


30866
#endif

30867


30868
        sfcnInitializeSampleTimes(childS);

30869


30870
        /* adjust sample time */

30871
        ssSetSampleTime(childS, 0, 0.0);

30872
        ssSetOffsetTime(childS, 0, 0.0);

30873
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

30874


30875
        /* set compiled values of dynamic vector attributes */

30876
        ssSetNumNonsampledZCs(childS, 0);

30877


30878
        /* Update connectivity flags for each port */

30879
        _ssSetInputPortConnected(childS, 0, 1);

30880
        _ssSetOutputPortConnected(childS, 0, 1);

30881
        _ssSetOutputPortBeingMerged(childS, 0, 0);

30882


30883
        /* Update the BufferDstPort flags for each input port */

30884
        _ssSetInputPortBufferDstPort(childS, 0, -1);

30885
      }

30886


30887
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S76>/Generated S-Function1 (SaturationLimiter_sf) */

30888
      {

30889
        SimStruct *childS = ssGetSFunction(rts, 117);

30890


30891
        /* timing info */

30892
        time_T *sfcnPeriod;

30893
        time_T *sfcnOffset;

30894
        int_T *sfcnTsMap;

30895
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

30896
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

30897
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

30898
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

30899
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

30900
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

30901
        (void) memset((void*)sfcnPeriod, 0,

30902
                      sizeof(time_T)*1);

30903
        (void) memset((void*)sfcnOffset, 0,

30904
                      sizeof(time_T)*1);

30905
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

30906
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

30907
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

30908


30909
        /* Set up the mdlInfo pointer */

30910
# ifdef USE_RTMODEL

30911


30912
        {

30913
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

30914
              struct _ssBlkInfo2));

30915
          ss_VALIDATE_MEMORY(rts,blkInfo2);

30916
          ssSetBlkInfo2Ptr(childS, blkInfo2);

30917
        }

30918


30919
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

30920


30921
# else

30922


30923
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

30924


30925
# endif                                /* USE_RTMODEL */

30926


30927
        /* Allocate memory of model methods 2 */

30928
        {

30929
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

30930
            malloc(sizeof(struct _ssSFcnModelMethods2));

30931
          ss_VALIDATE_MEMORY(rts,methods2);

30932
          ssSetModelMethods2(childS, methods2);

30933
        }

30934


30935
        /* Allocate memory of model methods 3 */

30936
        {

30937
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

30938
            malloc(sizeof(struct _ssSFcnModelMethods3));

30939
          ss_VALIDATE_MEMORY(rts,methods3);

30940
          ssSetModelMethods3(childS, methods3);

30941
        }

30942


30943
        /* Allocate memory for states auxilliary information */

30944
        {

30945
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

30946
            (sizeof(struct _ssStatesInfo2));

30947
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

30948
            malloc(sizeof(ssPeriodicStatesInfo));

30949
          ss_VALIDATE_MEMORY(rts,statesInfo2);

30950
          ssSetStatesInfo2(childS, statesInfo2);

30951
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

30952
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

30953
        }

30954


30955
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

30956
          RegNumInputPorts);

30957
        ssSetRegNumInputPortsFcnArg(childS,childS);

30958


30959
        /* inputs */

30960
        {

30961
          struct _ssPortInputs *inputPortInfo =

30962
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

30963
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

30964
          _ssSetNumInputPorts(childS, 3);

30965
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

30966


30967
          /* port 0 */

30968
          {

30969
            real32_T const **sfcnUPtrs = (real32_T const **)

30970
              malloc(1 * sizeof(real32_T *));

30971
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30972
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

30973
              ssGetLocalBlockIO(rts))->GeneratedSFunction6_j;

30974
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

30975
            _ssSetInputPortNumDimensions(childS, 0, 1);

30976
            ssSetInputPortWidth(childS, 0, 1);

30977
          }

30978


30979
          /* port 1 */

30980
          {

30981
            real32_T const **sfcnUPtrs = (real32_T const **)

30982
              malloc(1 * sizeof(real32_T *));

30983
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30984
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;

30985
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

30986
            _ssSetInputPortNumDimensions(childS, 1, 1);

30987
            ssSetInputPortWidth(childS, 1, 1);

30988
          }

30989


30990
          /* port 2 */

30991
          {

30992
            real32_T const **sfcnUPtrs = (real32_T const **)

30993
              malloc(1 * sizeof(real32_T *));

30994
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

30995
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;

30996
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

30997
            _ssSetInputPortNumDimensions(childS, 2, 1);

30998
            ssSetInputPortWidth(childS, 2, 1);

30999
          }

31000
        }

31001


31002
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

31003
          RegNumOutputPorts);

31004
        ssSetRegNumOutputPortsFcnArg(childS,childS);

31005


31006
        /* outputs */

31007
        {

31008
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

31009
            calloc(1, sizeof(struct _ssPortOutputs));

31010
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

31011
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

31012
          _ssSetNumOutputPorts(childS, 1);

31013


31014
          /* port 0 */

31015
          {

31016
            _ssSetOutputPortNumDimensions(childS, 0, 1);

31017
            ssSetOutputPortWidth(childS, 0, 1);

31018
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

31019
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_k));

31020
          }

31021
        }

31022


31023
        /* path info */

31024
        _ssSetModelName(childS, "SaturationLimiter_sf");

31025
        _ssSetPath(childS,

31026
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Saturation Limiter1/Generated S-Function1");

31027
        if (ssGetRTModel(rts) == (NULL)) {

31028
          _ssSetParentSS(childS, rts);

31029
          _ssSetRootSS(childS, ssGetRootSS(rts));

31030
        } else {

31031
          ssSetRTModel(childS,ssGetRTModel(rts));

31032
          _ssSetParentSS(childS, (NULL));

31033
          _ssSetRootSS(childS, childS);

31034
        }

31035


31036
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

31037
        (childS)->regDataType.arg1 = ((void *)(childS));

31038
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

31039
          FcnSetErrorStatus);

31040
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

31041
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

31042
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

31043
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

31044


31045
        /* registration */

31046
#if defined(MATLAB_MEX_FILE)

31047


31048
        {

31049
          int_T i;

31050
          mxArray *plhs[1];

31051
          mxArray *prhs[4];

31052
          double *pr;

31053
          volatile int_T *intS = (int_T *)&childS;

31054
          int_T addrlen = sizeof(SimStruct *);

31055
          int_T m = addrlen/sizeof(int_T) + 1;

31056
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

31057
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

31058
          pr = mxGetPr(prhs[1]);

31059
          for (i = 0; i < m - 1; i++) {

31060
            pr[i] = (double)intS[i];

31061
          }

31062


31063
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

31064
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

31065
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

31066


31067
          /* Reset port dimensions info functions because the S-function

31068
           * and accelerator mex-files explicitly set their dimensions,

31069
           * i.e., they are not dynamically sized. For this case, the

31070
           * mex-file is responsible for the dimensions info memory

31071
           * and Simulink should not free it. This is achieved by

31072
           * setting the following two methods to NULL.

31073
           */

31074
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

31075
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

31076


31077
          /*

31078
           * Setup function pointers and call mdlInitializeSizes via

31079
           * simulink.c

31080
           */

31081
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

31082
          mxDestroyArray(plhs[0]);

31083
          mxDestroyArray(prhs[0]);

31084
          mxDestroyArray(prhs[1]);

31085
          mxDestroyArray(prhs[2]);

31086
          mxDestroyArray(prhs[3]);

31087
        }

31088


31089
#else

31090


31091
        {

31092
          SaturationLimiter_sf(childS);

31093
          sfcnInitializeSizes(childS);

31094
        }

31095


31096
#endif

31097


31098
        sfcnInitializeSampleTimes(childS);

31099


31100
        /* adjust sample time */

31101
        ssSetSampleTime(childS, 0, 0.0);

31102
        ssSetOffsetTime(childS, 0, 0.0);

31103
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

31104


31105
        /* set compiled values of dynamic vector attributes */

31106
        ssSetNumNonsampledZCs(childS, 0);

31107


31108
        /* Update connectivity flags for each port */

31109
        _ssSetInputPortConnected(childS, 0, 1);

31110
        _ssSetInputPortConnected(childS, 1, 1);

31111
        _ssSetInputPortConnected(childS, 2, 1);

31112
        _ssSetOutputPortConnected(childS, 0, 1);

31113
        _ssSetOutputPortBeingMerged(childS, 0, 0);

31114


31115
        /* Update the BufferDstPort flags for each input port */

31116
        _ssSetInputPortBufferDstPort(childS, 0, -1);

31117
        _ssSetInputPortBufferDstPort(childS, 1, -1);

31118
        _ssSetInputPortBufferDstPort(childS, 2, -1);

31119
      }

31120


31121
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S78>/Generated S-Function (Gain_sf) */

31122
      {

31123
        SimStruct *childS = ssGetSFunction(rts, 118);

31124


31125
        /* timing info */

31126
        time_T *sfcnPeriod;

31127
        time_T *sfcnOffset;

31128
        int_T *sfcnTsMap;

31129
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

31130
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

31131
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

31132
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

31133
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

31134
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

31135
        (void) memset((void*)sfcnPeriod, 0,

31136
                      sizeof(time_T)*1);

31137
        (void) memset((void*)sfcnOffset, 0,

31138
                      sizeof(time_T)*1);

31139
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

31140
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

31141
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

31142


31143
        /* Set up the mdlInfo pointer */

31144
# ifdef USE_RTMODEL

31145


31146
        {

31147
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

31148
              struct _ssBlkInfo2));

31149
          ss_VALIDATE_MEMORY(rts,blkInfo2);

31150
          ssSetBlkInfo2Ptr(childS, blkInfo2);

31151
        }

31152


31153
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

31154


31155
# else

31156


31157
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

31158


31159
# endif                                /* USE_RTMODEL */

31160


31161
        /* Allocate memory of model methods 2 */

31162
        {

31163
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

31164
            malloc(sizeof(struct _ssSFcnModelMethods2));

31165
          ss_VALIDATE_MEMORY(rts,methods2);

31166
          ssSetModelMethods2(childS, methods2);

31167
        }

31168


31169
        /* Allocate memory of model methods 3 */

31170
        {

31171
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

31172
            malloc(sizeof(struct _ssSFcnModelMethods3));

31173
          ss_VALIDATE_MEMORY(rts,methods3);

31174
          ssSetModelMethods3(childS, methods3);

31175
        }

31176


31177
        /* Allocate memory for states auxilliary information */

31178
        {

31179
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

31180
            (sizeof(struct _ssStatesInfo2));

31181
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

31182
            malloc(sizeof(ssPeriodicStatesInfo));

31183
          ss_VALIDATE_MEMORY(rts,statesInfo2);

31184
          ssSetStatesInfo2(childS, statesInfo2);

31185
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

31186
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

31187
        }

31188


31189
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

31190
          RegNumInputPorts);

31191
        ssSetRegNumInputPortsFcnArg(childS,childS);

31192


31193
        /* inputs */

31194
        {

31195
          struct _ssPortInputs *inputPortInfo =

31196
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

31197
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

31198
          _ssSetNumInputPorts(childS, 2);

31199
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

31200


31201
          /* port 0 */

31202
          {

31203
            real32_T const **sfcnUPtrs = (real32_T const **)

31204
              malloc(1 * sizeof(real32_T *));

31205
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31206
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31207
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_k;

31208
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

31209
            _ssSetInputPortNumDimensions(childS, 0, 1);

31210
            ssSetInputPortWidth(childS, 0, 1);

31211
          }

31212


31213
          /* port 1 */

31214
          {

31215
            real32_T const **sfcnUPtrs = (real32_T const **)

31216
              malloc(1 * sizeof(real32_T *));

31217
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31218
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

31219
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

31220
            _ssSetInputPortNumDimensions(childS, 1, 1);

31221
            ssSetInputPortWidth(childS, 1, 1);

31222
          }

31223
        }

31224


31225
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

31226
          RegNumOutputPorts);

31227
        ssSetRegNumOutputPortsFcnArg(childS,childS);

31228


31229
        /* outputs */

31230
        {

31231
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

31232
            calloc(1, sizeof(struct _ssPortOutputs));

31233
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

31234
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

31235
          _ssSetNumOutputPorts(childS, 1);

31236


31237
          /* port 0 */

31238
          {

31239
            _ssSetOutputPortNumDimensions(childS, 0, 1);

31240
            ssSetOutputPortWidth(childS, 0, 1);

31241
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

31242
              ssGetLocalBlockIO(rts))->GeneratedSFunction_cq));

31243
          }

31244
        }

31245


31246
        /* path info */

31247
        _ssSetModelName(childS, "Gain_sf");

31248
        _ssSetPath(childS,

31249
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/gain2/Generated S-Function");

31250
        if (ssGetRTModel(rts) == (NULL)) {

31251
          _ssSetParentSS(childS, rts);

31252
          _ssSetRootSS(childS, ssGetRootSS(rts));

31253
        } else {

31254
          ssSetRTModel(childS,ssGetRTModel(rts));

31255
          _ssSetParentSS(childS, (NULL));

31256
          _ssSetRootSS(childS, childS);

31257
        }

31258


31259
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

31260
        (childS)->regDataType.arg1 = ((void *)(childS));

31261
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

31262
          FcnSetErrorStatus);

31263
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

31264
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

31265
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

31266
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

31267


31268
        /* registration */

31269
#if defined(MATLAB_MEX_FILE)

31270


31271
        {

31272
          int_T i;

31273
          mxArray *plhs[1];

31274
          mxArray *prhs[4];

31275
          double *pr;

31276
          volatile int_T *intS = (int_T *)&childS;

31277
          int_T addrlen = sizeof(SimStruct *);

31278
          int_T m = addrlen/sizeof(int_T) + 1;

31279
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

31280
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

31281
          pr = mxGetPr(prhs[1]);

31282
          for (i = 0; i < m - 1; i++) {

31283
            pr[i] = (double)intS[i];

31284
          }

31285


31286
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

31287
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

31288
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

31289


31290
          /* Reset port dimensions info functions because the S-function

31291
           * and accelerator mex-files explicitly set their dimensions,

31292
           * i.e., they are not dynamically sized. For this case, the

31293
           * mex-file is responsible for the dimensions info memory

31294
           * and Simulink should not free it. This is achieved by

31295
           * setting the following two methods to NULL.

31296
           */

31297
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

31298
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

31299


31300
          /*

31301
           * Setup function pointers and call mdlInitializeSizes via

31302
           * simulink.c

31303
           */

31304
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

31305
          mxDestroyArray(plhs[0]);

31306
          mxDestroyArray(prhs[0]);

31307
          mxDestroyArray(prhs[1]);

31308
          mxDestroyArray(prhs[2]);

31309
          mxDestroyArray(prhs[3]);

31310
        }

31311


31312
#else

31313


31314
        {

31315
          Gain_sf(childS);

31316
          sfcnInitializeSizes(childS);

31317
        }

31318


31319
#endif

31320


31321
        sfcnInitializeSampleTimes(childS);

31322


31323
        /* adjust sample time */

31324
        ssSetSampleTime(childS, 0, 0.0);

31325
        ssSetOffsetTime(childS, 0, 0.0);

31326
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

31327


31328
        /* set compiled values of dynamic vector attributes */

31329
        ssSetNumNonsampledZCs(childS, 0);

31330


31331
        /* Update connectivity flags for each port */

31332
        _ssSetInputPortConnected(childS, 0, 1);

31333
        _ssSetInputPortConnected(childS, 1, 1);

31334
        _ssSetOutputPortConnected(childS, 0, 1);

31335
        _ssSetOutputPortBeingMerged(childS, 0, 0);

31336


31337
        /* Update the BufferDstPort flags for each input port */

31338
        _ssSetInputPortBufferDstPort(childS, 0, -1);

31339
        _ssSetInputPortBufferDstPort(childS, 1, -1);

31340
      }

31341


31342
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S75>/Generated S-Function2 (LeadLagFilter_sf) */

31343
      {

31344
        SimStruct *childS = ssGetSFunction(rts, 119);

31345


31346
        /* timing info */

31347
        time_T *sfcnPeriod;

31348
        time_T *sfcnOffset;

31349
        int_T *sfcnTsMap;

31350
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

31351
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

31352
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

31353
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

31354
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

31355
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

31356
        (void) memset((void*)sfcnPeriod, 0,

31357
                      sizeof(time_T)*1);

31358
        (void) memset((void*)sfcnOffset, 0,

31359
                      sizeof(time_T)*1);

31360
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

31361
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

31362
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

31363


31364
        /* Set up the mdlInfo pointer */

31365
# ifdef USE_RTMODEL

31366


31367
        {

31368
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

31369
              struct _ssBlkInfo2));

31370
          ss_VALIDATE_MEMORY(rts,blkInfo2);

31371
          ssSetBlkInfo2Ptr(childS, blkInfo2);

31372
        }

31373


31374
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

31375


31376
# else

31377


31378
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

31379


31380
# endif                                /* USE_RTMODEL */

31381


31382
        /* Allocate memory of model methods 2 */

31383
        {

31384
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

31385
            malloc(sizeof(struct _ssSFcnModelMethods2));

31386
          ss_VALIDATE_MEMORY(rts,methods2);

31387
          ssSetModelMethods2(childS, methods2);

31388
        }

31389


31390
        /* Allocate memory of model methods 3 */

31391
        {

31392
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

31393
            malloc(sizeof(struct _ssSFcnModelMethods3));

31394
          ss_VALIDATE_MEMORY(rts,methods3);

31395
          ssSetModelMethods3(childS, methods3);

31396
        }

31397


31398
        /* Allocate memory for states auxilliary information */

31399
        {

31400
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

31401
            (sizeof(struct _ssStatesInfo2));

31402
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

31403
            malloc(sizeof(ssPeriodicStatesInfo));

31404
          ss_VALIDATE_MEMORY(rts,statesInfo2);

31405
          ssSetStatesInfo2(childS, statesInfo2);

31406
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

31407
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

31408
        }

31409


31410
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

31411
          RegNumInputPorts);

31412
        ssSetRegNumInputPortsFcnArg(childS,childS);

31413


31414
        /* inputs */

31415
        {

31416
          struct _ssPortInputs *inputPortInfo =

31417
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

31418
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

31419
          _ssSetNumInputPorts(childS, 7);

31420
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

31421


31422
          /* port 0 */

31423
          {

31424
            real32_T const **sfcnUPtrs = (real32_T const **)

31425
              malloc(1 * sizeof(real32_T *));

31426
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31427
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31428
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

31429
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

31430
            _ssSetInputPortNumDimensions(childS, 0, 1);

31431
            ssSetInputPortWidth(childS, 0, 1);

31432
          }

31433


31434
          /* port 1 */

31435
          {

31436
            int8_T const **sfcnUPtrs = (int8_T const **)

31437
              malloc(1 * sizeof(int8_T *));

31438
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31439
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

31440
              ssGetLocalBlockIO(rts))->DataTypeConversion1_jy;

31441
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

31442
            _ssSetInputPortNumDimensions(childS, 1, 1);

31443
            ssSetInputPortWidth(childS, 1, 1);

31444
          }

31445


31446
          /* port 2 */

31447
          {

31448
            real32_T const **sfcnUPtrs = (real32_T const **)

31449
              malloc(1 * sizeof(real32_T *));

31450
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31451
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

31452
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

31453
            _ssSetInputPortNumDimensions(childS, 2, 1);

31454
            ssSetInputPortWidth(childS, 2, 1);

31455
          }

31456


31457
          /* port 3 */

31458
          {

31459
            real32_T const **sfcnUPtrs = (real32_T const **)

31460
              malloc(1 * sizeof(real32_T *));

31461
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31462
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

31463
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

31464
            _ssSetInputPortNumDimensions(childS, 3, 1);

31465
            ssSetInputPortWidth(childS, 3, 1);

31466
          }

31467


31468
          /* port 4 */

31469
          {

31470
            real32_T const **sfcnUPtrs = (real32_T const **)

31471
              malloc(1 * sizeof(real32_T *));

31472
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31473
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31474
              ssGetLocalBlockIO(rts))->Switch_fz;

31475
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

31476
            _ssSetInputPortNumDimensions(childS, 4, 1);

31477
            ssSetInputPortWidth(childS, 4, 1);

31478
          }

31479


31480
          /* port 5 */

31481
          {

31482
            real32_T const **sfcnUPtrs = (real32_T const **)

31483
              malloc(1 * sizeof(real32_T *));

31484
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31485
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31486
              ssGetLocalBlockIO(rts))->Switch_fz;

31487
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

31488
            _ssSetInputPortNumDimensions(childS, 5, 1);

31489
            ssSetInputPortWidth(childS, 5, 1);

31490
          }

31491


31492
          /* port 6 */

31493
          {

31494
            real32_T const **sfcnUPtrs = (real32_T const **)

31495
              malloc(1 * sizeof(real32_T *));

31496
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31497
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31498
              ssGetLocalBlockIO(rts))->GeneratedSFunction_cq;

31499
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

31500
            _ssSetInputPortNumDimensions(childS, 6, 1);

31501
            ssSetInputPortWidth(childS, 6, 1);

31502
          }

31503
        }

31504


31505
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

31506
          RegNumOutputPorts);

31507
        ssSetRegNumOutputPortsFcnArg(childS,childS);

31508


31509
        /* outputs */

31510
        {

31511
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

31512
            calloc(1, sizeof(struct _ssPortOutputs));

31513
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

31514
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

31515
          _ssSetNumOutputPorts(childS, 1);

31516


31517
          /* port 0 */

31518
          {

31519
            _ssSetOutputPortNumDimensions(childS, 0, 1);

31520
            ssSetOutputPortWidth(childS, 0, 1);

31521
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

31522
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_m5));

31523
          }

31524
        }

31525


31526
        /* path info */

31527
        _ssSetModelName(childS, "LeadLagFilter_sf");

31528
        _ssSetPath(childS,

31529
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Lead lag1/Generated S-Function2");

31530
        if (ssGetRTModel(rts) == (NULL)) {

31531
          _ssSetParentSS(childS, rts);

31532
          _ssSetRootSS(childS, ssGetRootSS(rts));

31533
        } else {

31534
          ssSetRTModel(childS,ssGetRTModel(rts));

31535
          _ssSetParentSS(childS, (NULL));

31536
          _ssSetRootSS(childS, childS);

31537
        }

31538


31539
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

31540


31541
        /* work vectors */

31542
        {

31543
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

31544
            (4 * sizeof(struct _ssDWorkRecord));

31545
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

31546
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

31547
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

31548
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

31549
          ssSetSFcnDWork(childS, dWorkRecord);

31550
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

31551
          _ssSetNumDWork(childS, 4);

31552


31553
          /* DWORK0 */

31554
          ssSetDWorkWidth(childS, 0, 1);

31555
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

31556
          ssSetDWorkComplexSignal(childS, 0, 0);

31557
          ssSetDWorkUsedAsDState(childS, 0, 1);

31558
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 236))[0]);

31559


31560
          /* DWORK1 */

31561
          ssSetDWorkWidth(childS, 1, 1);

31562
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

31563
          ssSetDWorkComplexSignal(childS, 1, 0);

31564
          ssSetDWorkUsedAsDState(childS, 1, 1);

31565
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 237))[0]);

31566


31567
          /* DWORK2 */

31568
          ssSetDWorkWidth(childS, 2, 1);

31569
          ssSetDWorkDataType(childS, 2,SS_INT8);

31570
          ssSetDWorkComplexSignal(childS, 2, 0);

31571
          ssSetDWorkUsedAsDState(childS, 2, 1);

31572
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 463))[0]);

31573


31574
          /* DWORK3 */

31575
          ssSetDWorkWidth(childS, 3, 1);

31576
          ssSetDWorkDataType(childS, 3,SS_INT8);

31577
          ssSetDWorkComplexSignal(childS, 3, 0);

31578
          ssSetDWorkUsedAsDState(childS, 3, 1);

31579
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 464))[0]);

31580
        }

31581


31582
        (childS)->regDataType.arg1 = ((void *)(childS));

31583
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

31584
          FcnSetErrorStatus);

31585
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

31586
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

31587
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

31588
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

31589


31590
        /* registration */

31591
#if defined(MATLAB_MEX_FILE)

31592


31593
        {

31594
          int_T i;

31595
          mxArray *plhs[1];

31596
          mxArray *prhs[4];

31597
          double *pr;

31598
          volatile int_T *intS = (int_T *)&childS;

31599
          int_T addrlen = sizeof(SimStruct *);

31600
          int_T m = addrlen/sizeof(int_T) + 1;

31601
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

31602
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

31603
          pr = mxGetPr(prhs[1]);

31604
          for (i = 0; i < m - 1; i++) {

31605
            pr[i] = (double)intS[i];

31606
          }

31607


31608
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

31609
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

31610
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

31611


31612
          /* Reset port dimensions info functions because the S-function

31613
           * and accelerator mex-files explicitly set their dimensions,

31614
           * i.e., they are not dynamically sized. For this case, the

31615
           * mex-file is responsible for the dimensions info memory

31616
           * and Simulink should not free it. This is achieved by

31617
           * setting the following two methods to NULL.

31618
           */

31619
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

31620
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

31621


31622
          /*

31623
           * Setup function pointers and call mdlInitializeSizes via

31624
           * simulink.c

31625
           */

31626
          mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");

31627
          mxDestroyArray(plhs[0]);

31628
          mxDestroyArray(prhs[0]);

31629
          mxDestroyArray(prhs[1]);

31630
          mxDestroyArray(prhs[2]);

31631
          mxDestroyArray(prhs[3]);

31632
        }

31633


31634
#else

31635


31636
        {

31637
          LeadLagFilter_sf(childS);

31638
          sfcnInitializeSizes(childS);

31639
        }

31640


31641
#endif

31642


31643
        sfcnInitializeSampleTimes(childS);

31644


31645
        /* adjust sample time */

31646
        ssSetSampleTime(childS, 0, 0.0);

31647
        ssSetOffsetTime(childS, 0, 0.0);

31648
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

31649


31650
        /* set compiled values of dynamic vector attributes */

31651
        ssSetNumNonsampledZCs(childS, 0);

31652


31653
        /* Update connectivity flags for each port */

31654
        _ssSetInputPortConnected(childS, 0, 1);

31655
        _ssSetInputPortConnected(childS, 1, 1);

31656
        _ssSetInputPortConnected(childS, 2, 1);

31657
        _ssSetInputPortConnected(childS, 3, 1);

31658
        _ssSetInputPortConnected(childS, 4, 1);

31659
        _ssSetInputPortConnected(childS, 5, 1);

31660
        _ssSetInputPortConnected(childS, 6, 1);

31661
        _ssSetOutputPortConnected(childS, 0, 1);

31662
        _ssSetOutputPortBeingMerged(childS, 0, 0);

31663


31664
        /* Update the BufferDstPort flags for each input port */

31665
        _ssSetInputPortBufferDstPort(childS, 0, -1);

31666
        _ssSetInputPortBufferDstPort(childS, 1, -1);

31667
        _ssSetInputPortBufferDstPort(childS, 2, -1);

31668
        _ssSetInputPortBufferDstPort(childS, 3, -1);

31669
        _ssSetInputPortBufferDstPort(childS, 4, -1);

31670
        _ssSetInputPortBufferDstPort(childS, 5, -1);

31671
        _ssSetInputPortBufferDstPort(childS, 6, -1);

31672
      }

31673


31674
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S74>/Generated S-Function4 (LagFilter_sf) */

31675
      {

31676
        SimStruct *childS = ssGetSFunction(rts, 120);

31677


31678
        /* timing info */

31679
        time_T *sfcnPeriod;

31680
        time_T *sfcnOffset;

31681
        int_T *sfcnTsMap;

31682
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

31683
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

31684
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

31685
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

31686
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

31687
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

31688
        (void) memset((void*)sfcnPeriod, 0,

31689
                      sizeof(time_T)*1);

31690
        (void) memset((void*)sfcnOffset, 0,

31691
                      sizeof(time_T)*1);

31692
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

31693
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

31694
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

31695


31696
        /* Set up the mdlInfo pointer */

31697
# ifdef USE_RTMODEL

31698


31699
        {

31700
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

31701
              struct _ssBlkInfo2));

31702
          ss_VALIDATE_MEMORY(rts,blkInfo2);

31703
          ssSetBlkInfo2Ptr(childS, blkInfo2);

31704
        }

31705


31706
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

31707


31708
# else

31709


31710
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

31711


31712
# endif                                /* USE_RTMODEL */

31713


31714
        /* Allocate memory of model methods 2 */

31715
        {

31716
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

31717
            malloc(sizeof(struct _ssSFcnModelMethods2));

31718
          ss_VALIDATE_MEMORY(rts,methods2);

31719
          ssSetModelMethods2(childS, methods2);

31720
        }

31721


31722
        /* Allocate memory of model methods 3 */

31723
        {

31724
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

31725
            malloc(sizeof(struct _ssSFcnModelMethods3));

31726
          ss_VALIDATE_MEMORY(rts,methods3);

31727
          ssSetModelMethods3(childS, methods3);

31728
        }

31729


31730
        /* Allocate memory for states auxilliary information */

31731
        {

31732
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

31733
            (sizeof(struct _ssStatesInfo2));

31734
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

31735
            malloc(sizeof(ssPeriodicStatesInfo));

31736
          ss_VALIDATE_MEMORY(rts,statesInfo2);

31737
          ssSetStatesInfo2(childS, statesInfo2);

31738
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

31739
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

31740
        }

31741


31742
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

31743
          RegNumInputPorts);

31744
        ssSetRegNumInputPortsFcnArg(childS,childS);

31745


31746
        /* inputs */

31747
        {

31748
          struct _ssPortInputs *inputPortInfo =

31749
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

31750
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

31751
          _ssSetNumInputPorts(childS, 6);

31752
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

31753


31754
          /* port 0 */

31755
          {

31756
            real32_T const **sfcnUPtrs = (real32_T const **)

31757
              malloc(1 * sizeof(real32_T *));

31758
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31759
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31760
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;

31761
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

31762
            _ssSetInputPortNumDimensions(childS, 0, 1);

31763
            ssSetInputPortWidth(childS, 0, 1);

31764
          }

31765


31766
          /* port 1 */

31767
          {

31768
            int8_T const **sfcnUPtrs = (int8_T const **)

31769
              malloc(1 * sizeof(int8_T *));

31770
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31771
            sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)

31772
              ssGetLocalBlockIO(rts))->DataTypeConversion1_jy;

31773
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

31774
            _ssSetInputPortNumDimensions(childS, 1, 1);

31775
            ssSetInputPortWidth(childS, 1, 1);

31776
          }

31777


31778
          /* port 2 */

31779
          {

31780
            real32_T const **sfcnUPtrs = (real32_T const **)

31781
              malloc(1 * sizeof(real32_T *));

31782
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31783
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;

31784
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

31785
            _ssSetInputPortNumDimensions(childS, 2, 1);

31786
            ssSetInputPortWidth(childS, 2, 1);

31787
          }

31788


31789
          /* port 3 */

31790
          {

31791
            real32_T const **sfcnUPtrs = (real32_T const **)

31792
              malloc(1 * sizeof(real32_T *));

31793
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31794
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31795
              ssGetLocalBlockIO(rts))->Switch_fz;

31796
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

31797
            _ssSetInputPortNumDimensions(childS, 3, 1);

31798
            ssSetInputPortWidth(childS, 3, 1);

31799
          }

31800


31801
          /* port 4 */

31802
          {

31803
            real32_T const **sfcnUPtrs = (real32_T const **)

31804
              malloc(1 * sizeof(real32_T *));

31805
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31806
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31807
              ssGetLocalBlockIO(rts))->Switch_fz;

31808
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

31809
            _ssSetInputPortNumDimensions(childS, 4, 1);

31810
            ssSetInputPortWidth(childS, 4, 1);

31811
          }

31812


31813
          /* port 5 */

31814
          {

31815
            real32_T const **sfcnUPtrs = (real32_T const **)

31816
              malloc(1 * sizeof(real32_T *));

31817
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

31818
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

31819
              ssGetLocalBlockIO(rts))->GeneratedSFunction2_m5;

31820
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

31821
            _ssSetInputPortNumDimensions(childS, 5, 1);

31822
            ssSetInputPortWidth(childS, 5, 1);

31823
          }

31824
        }

31825


31826
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

31827
          RegNumOutputPorts);

31828
        ssSetRegNumOutputPortsFcnArg(childS,childS);

31829


31830
        /* outputs */

31831
        {

31832
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

31833
            calloc(1, sizeof(struct _ssPortOutputs));

31834
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

31835
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

31836
          _ssSetNumOutputPorts(childS, 1);

31837


31838
          /* port 0 */

31839
          {

31840
            _ssSetOutputPortNumDimensions(childS, 0, 1);

31841
            ssSetOutputPortWidth(childS, 0, 1);

31842
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

31843
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_cw));

31844
          }

31845
        }

31846


31847
        /* path info */

31848
        _ssSetModelName(childS, "LagFilter_sf");

31849
        _ssSetPath(childS,

31850
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/ lag filter/Generated S-Function4");

31851
        if (ssGetRTModel(rts) == (NULL)) {

31852
          _ssSetParentSS(childS, rts);

31853
          _ssSetRootSS(childS, ssGetRootSS(rts));

31854
        } else {

31855
          ssSetRTModel(childS,ssGetRTModel(rts));

31856
          _ssSetParentSS(childS, (NULL));

31857
          _ssSetRootSS(childS, childS);

31858
        }

31859


31860
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

31861


31862
        /* work vectors */

31863
        {

31864
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

31865
            (4 * sizeof(struct _ssDWorkRecord));

31866
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

31867
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

31868
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

31869
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

31870
          ssSetSFcnDWork(childS, dWorkRecord);

31871
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

31872
          _ssSetNumDWork(childS, 4);

31873


31874
          /* DWORK0 */

31875
          ssSetDWorkWidth(childS, 0, 1);

31876
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

31877
          ssSetDWorkComplexSignal(childS, 0, 0);

31878
          ssSetDWorkUsedAsDState(childS, 0, 1);

31879
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 238))[0]);

31880


31881
          /* DWORK1 */

31882
          ssSetDWorkWidth(childS, 1, 1);

31883
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

31884
          ssSetDWorkComplexSignal(childS, 1, 0);

31885
          ssSetDWorkUsedAsDState(childS, 1, 1);

31886
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 239))[0]);

31887


31888
          /* DWORK2 */

31889
          ssSetDWorkWidth(childS, 2, 1);

31890
          ssSetDWorkDataType(childS, 2,SS_INT8);

31891
          ssSetDWorkComplexSignal(childS, 2, 0);

31892
          ssSetDWorkUsedAsDState(childS, 2, 1);

31893
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 465))[0]);

31894


31895
          /* DWORK3 */

31896
          ssSetDWorkWidth(childS, 3, 1);

31897
          ssSetDWorkDataType(childS, 3,SS_INT8);

31898
          ssSetDWorkComplexSignal(childS, 3, 0);

31899
          ssSetDWorkUsedAsDState(childS, 3, 1);

31900
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 466))[0]);

31901
        }

31902


31903
        (childS)->regDataType.arg1 = ((void *)(childS));

31904
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

31905
          FcnSetErrorStatus);

31906
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

31907
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

31908
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

31909
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

31910


31911
        /* registration */

31912
#if defined(MATLAB_MEX_FILE)

31913


31914
        {

31915
          int_T i;

31916
          mxArray *plhs[1];

31917
          mxArray *prhs[4];

31918
          double *pr;

31919
          volatile int_T *intS = (int_T *)&childS;

31920
          int_T addrlen = sizeof(SimStruct *);

31921
          int_T m = addrlen/sizeof(int_T) + 1;

31922
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

31923
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

31924
          pr = mxGetPr(prhs[1]);

31925
          for (i = 0; i < m - 1; i++) {

31926
            pr[i] = (double)intS[i];

31927
          }

31928


31929
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

31930
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

31931
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

31932


31933
          /* Reset port dimensions info functions because the S-function

31934
           * and accelerator mex-files explicitly set their dimensions,

31935
           * i.e., they are not dynamically sized. For this case, the

31936
           * mex-file is responsible for the dimensions info memory

31937
           * and Simulink should not free it. This is achieved by

31938
           * setting the following two methods to NULL.

31939
           */

31940
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

31941
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

31942


31943
          /*

31944
           * Setup function pointers and call mdlInitializeSizes via

31945
           * simulink.c

31946
           */

31947
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

31948
          mxDestroyArray(plhs[0]);

31949
          mxDestroyArray(prhs[0]);

31950
          mxDestroyArray(prhs[1]);

31951
          mxDestroyArray(prhs[2]);

31952
          mxDestroyArray(prhs[3]);

31953
        }

31954


31955
#else

31956


31957
        {

31958
          LagFilter_sf(childS);

31959
          sfcnInitializeSizes(childS);

31960
        }

31961


31962
#endif

31963


31964
        sfcnInitializeSampleTimes(childS);

31965


31966
        /* adjust sample time */

31967
        ssSetSampleTime(childS, 0, 0.0);

31968
        ssSetOffsetTime(childS, 0, 0.0);

31969
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

31970


31971
        /* set compiled values of dynamic vector attributes */

31972
        ssSetNumNonsampledZCs(childS, 0);

31973


31974
        /* Update connectivity flags for each port */

31975
        _ssSetInputPortConnected(childS, 0, 1);

31976
        _ssSetInputPortConnected(childS, 1, 1);

31977
        _ssSetInputPortConnected(childS, 2, 1);

31978
        _ssSetInputPortConnected(childS, 3, 1);

31979
        _ssSetInputPortConnected(childS, 4, 1);

31980
        _ssSetInputPortConnected(childS, 5, 1);

31981
        _ssSetOutputPortConnected(childS, 0, 1);

31982
        _ssSetOutputPortBeingMerged(childS, 0, 0);

31983


31984
        /* Update the BufferDstPort flags for each input port */

31985
        _ssSetInputPortBufferDstPort(childS, 0, -1);

31986
        _ssSetInputPortBufferDstPort(childS, 1, -1);

31987
        _ssSetInputPortBufferDstPort(childS, 2, -1);

31988
        _ssSetInputPortBufferDstPort(childS, 3, -1);

31989
        _ssSetInputPortBufferDstPort(childS, 4, -1);

31990
        _ssSetInputPortBufferDstPort(childS, 5, -1);

31991
      }

31992


31993
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S209>/Generated S-Function1 (SaturationLimiter_sf) */

31994
      {

31995
        SimStruct *childS = ssGetSFunction(rts, 121);

31996


31997
        /* timing info */

31998
        time_T *sfcnPeriod;

31999
        time_T *sfcnOffset;

32000
        int_T *sfcnTsMap;

32001
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

32002
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

32003
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

32004
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

32005
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

32006
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

32007
        (void) memset((void*)sfcnPeriod, 0,

32008
                      sizeof(time_T)*1);

32009
        (void) memset((void*)sfcnOffset, 0,

32010
                      sizeof(time_T)*1);

32011
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

32012
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

32013
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

32014


32015
        /* Set up the mdlInfo pointer */

32016
# ifdef USE_RTMODEL

32017


32018
        {

32019
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

32020
              struct _ssBlkInfo2));

32021
          ss_VALIDATE_MEMORY(rts,blkInfo2);

32022
          ssSetBlkInfo2Ptr(childS, blkInfo2);

32023
        }

32024


32025
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

32026


32027
# else

32028


32029
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

32030


32031
# endif                                /* USE_RTMODEL */

32032


32033
        /* Allocate memory of model methods 2 */

32034
        {

32035
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

32036
            malloc(sizeof(struct _ssSFcnModelMethods2));

32037
          ss_VALIDATE_MEMORY(rts,methods2);

32038
          ssSetModelMethods2(childS, methods2);

32039
        }

32040


32041
        /* Allocate memory of model methods 3 */

32042
        {

32043
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

32044
            malloc(sizeof(struct _ssSFcnModelMethods3));

32045
          ss_VALIDATE_MEMORY(rts,methods3);

32046
          ssSetModelMethods3(childS, methods3);

32047
        }

32048


32049
        /* Allocate memory for states auxilliary information */

32050
        {

32051
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

32052
            (sizeof(struct _ssStatesInfo2));

32053
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

32054
            malloc(sizeof(ssPeriodicStatesInfo));

32055
          ss_VALIDATE_MEMORY(rts,statesInfo2);

32056
          ssSetStatesInfo2(childS, statesInfo2);

32057
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

32058
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

32059
        }

32060


32061
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

32062
          RegNumInputPorts);

32063
        ssSetRegNumInputPortsFcnArg(childS,childS);

32064


32065
        /* inputs */

32066
        {

32067
          struct _ssPortInputs *inputPortInfo =

32068
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

32069
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

32070
          _ssSetNumInputPorts(childS, 3);

32071
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

32072


32073
          /* port 0 */

32074
          {

32075
            real32_T const **sfcnUPtrs = (real32_T const **)

32076
              malloc(1 * sizeof(real32_T *));

32077
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32078
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32079
              ssGetLocalBlockIO(rts))->Switch_lr;

32080
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

32081
            _ssSetInputPortNumDimensions(childS, 0, 1);

32082
            ssSetInputPortWidth(childS, 0, 1);

32083
          }

32084


32085
          /* port 1 */

32086
          {

32087
            real32_T const **sfcnUPtrs = (real32_T const **)

32088
              malloc(1 * sizeof(real32_T *));

32089
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32090
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

32091
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

32092
            _ssSetInputPortNumDimensions(childS, 1, 1);

32093
            ssSetInputPortWidth(childS, 1, 1);

32094
          }

32095


32096
          /* port 2 */

32097
          {

32098
            real32_T const **sfcnUPtrs = (real32_T const **)

32099
              malloc(1 * sizeof(real32_T *));

32100
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32101
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

32102
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

32103
            _ssSetInputPortNumDimensions(childS, 2, 1);

32104
            ssSetInputPortWidth(childS, 2, 1);

32105
          }

32106
        }

32107


32108
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

32109
          RegNumOutputPorts);

32110
        ssSetRegNumOutputPortsFcnArg(childS,childS);

32111


32112
        /* outputs */

32113
        {

32114
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

32115
            calloc(1, sizeof(struct _ssPortOutputs));

32116
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

32117
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

32118
          _ssSetNumOutputPorts(childS, 1);

32119


32120
          /* port 0 */

32121
          {

32122
            _ssSetOutputPortNumDimensions(childS, 0, 1);

32123
            ssSetOutputPortWidth(childS, 0, 1);

32124
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

32125
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_oi));

32126
          }

32127
        }

32128


32129
        /* path info */

32130
        _ssSetModelName(childS, "SaturationLimiter_sf");

32131
        _ssSetPath(childS,

32132
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/Saturation Limiter/Generated S-Function1");

32133
        if (ssGetRTModel(rts) == (NULL)) {

32134
          _ssSetParentSS(childS, rts);

32135
          _ssSetRootSS(childS, ssGetRootSS(rts));

32136
        } else {

32137
          ssSetRTModel(childS,ssGetRTModel(rts));

32138
          _ssSetParentSS(childS, (NULL));

32139
          _ssSetRootSS(childS, childS);

32140
        }

32141


32142
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

32143
        (childS)->regDataType.arg1 = ((void *)(childS));

32144
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

32145
          FcnSetErrorStatus);

32146
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

32147
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

32148
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

32149
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

32150


32151
        /* registration */

32152
#if defined(MATLAB_MEX_FILE)

32153


32154
        {

32155
          int_T i;

32156
          mxArray *plhs[1];

32157
          mxArray *prhs[4];

32158
          double *pr;

32159
          volatile int_T *intS = (int_T *)&childS;

32160
          int_T addrlen = sizeof(SimStruct *);

32161
          int_T m = addrlen/sizeof(int_T) + 1;

32162
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

32163
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

32164
          pr = mxGetPr(prhs[1]);

32165
          for (i = 0; i < m - 1; i++) {

32166
            pr[i] = (double)intS[i];

32167
          }

32168


32169
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

32170
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

32171
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

32172


32173
          /* Reset port dimensions info functions because the S-function

32174
           * and accelerator mex-files explicitly set their dimensions,

32175
           * i.e., they are not dynamically sized. For this case, the

32176
           * mex-file is responsible for the dimensions info memory

32177
           * and Simulink should not free it. This is achieved by

32178
           * setting the following two methods to NULL.

32179
           */

32180
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

32181
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

32182


32183
          /*

32184
           * Setup function pointers and call mdlInitializeSizes via

32185
           * simulink.c

32186
           */

32187
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

32188
          mxDestroyArray(plhs[0]);

32189
          mxDestroyArray(prhs[0]);

32190
          mxDestroyArray(prhs[1]);

32191
          mxDestroyArray(prhs[2]);

32192
          mxDestroyArray(prhs[3]);

32193
        }

32194


32195
#else

32196


32197
        {

32198
          SaturationLimiter_sf(childS);

32199
          sfcnInitializeSizes(childS);

32200
        }

32201


32202
#endif

32203


32204
        sfcnInitializeSampleTimes(childS);

32205


32206
        /* adjust sample time */

32207
        ssSetSampleTime(childS, 0, 0.0);

32208
        ssSetOffsetTime(childS, 0, 0.0);

32209
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

32210


32211
        /* set compiled values of dynamic vector attributes */

32212
        ssSetNumNonsampledZCs(childS, 0);

32213


32214
        /* Update connectivity flags for each port */

32215
        _ssSetInputPortConnected(childS, 0, 1);

32216
        _ssSetInputPortConnected(childS, 1, 1);

32217
        _ssSetInputPortConnected(childS, 2, 1);

32218
        _ssSetOutputPortConnected(childS, 0, 1);

32219
        _ssSetOutputPortBeingMerged(childS, 0, 0);

32220


32221
        /* Update the BufferDstPort flags for each input port */

32222
        _ssSetInputPortBufferDstPort(childS, 0, -1);

32223
        _ssSetInputPortBufferDstPort(childS, 1, -1);

32224
        _ssSetInputPortBufferDstPort(childS, 2, -1);

32225
      }

32226


32227
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S208>/Generated S-Function (RateLimiter_sf) */

32228
      {

32229
        SimStruct *childS = ssGetSFunction(rts, 122);

32230


32231
        /* timing info */

32232
        time_T *sfcnPeriod;

32233
        time_T *sfcnOffset;

32234
        int_T *sfcnTsMap;

32235
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

32236
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

32237
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

32238
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

32239
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

32240
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

32241
        (void) memset((void*)sfcnPeriod, 0,

32242
                      sizeof(time_T)*1);

32243
        (void) memset((void*)sfcnOffset, 0,

32244
                      sizeof(time_T)*1);

32245
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

32246
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

32247
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

32248


32249
        /* Set up the mdlInfo pointer */

32250
# ifdef USE_RTMODEL

32251


32252
        {

32253
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

32254
              struct _ssBlkInfo2));

32255
          ss_VALIDATE_MEMORY(rts,blkInfo2);

32256
          ssSetBlkInfo2Ptr(childS, blkInfo2);

32257
        }

32258


32259
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

32260


32261
# else

32262


32263
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

32264


32265
# endif                                /* USE_RTMODEL */

32266


32267
        /* Allocate memory of model methods 2 */

32268
        {

32269
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

32270
            malloc(sizeof(struct _ssSFcnModelMethods2));

32271
          ss_VALIDATE_MEMORY(rts,methods2);

32272
          ssSetModelMethods2(childS, methods2);

32273
        }

32274


32275
        /* Allocate memory of model methods 3 */

32276
        {

32277
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

32278
            malloc(sizeof(struct _ssSFcnModelMethods3));

32279
          ss_VALIDATE_MEMORY(rts,methods3);

32280
          ssSetModelMethods3(childS, methods3);

32281
        }

32282


32283
        /* Allocate memory for states auxilliary information */

32284
        {

32285
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

32286
            (sizeof(struct _ssStatesInfo2));

32287
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

32288
            malloc(sizeof(ssPeriodicStatesInfo));

32289
          ss_VALIDATE_MEMORY(rts,statesInfo2);

32290
          ssSetStatesInfo2(childS, statesInfo2);

32291
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

32292
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

32293
        }

32294


32295
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

32296
          RegNumInputPorts);

32297
        ssSetRegNumInputPortsFcnArg(childS,childS);

32298


32299
        /* inputs */

32300
        {

32301
          struct _ssPortInputs *inputPortInfo =

32302
            (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));

32303
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

32304
          _ssSetNumInputPorts(childS, 5);

32305
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

32306


32307
          /* port 0 */

32308
          {

32309
            int8_T const **sfcnUPtrs = (int8_T const **)

32310
              malloc(1 * sizeof(int8_T *));

32311
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32312
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

32313
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

32314
            _ssSetInputPortNumDimensions(childS, 0, 1);

32315
            ssSetInputPortWidth(childS, 0, 1);

32316
          }

32317


32318
          /* port 1 */

32319
          {

32320
            real32_T const **sfcnUPtrs = (real32_T const **)

32321
              malloc(1 * sizeof(real32_T *));

32322
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32323
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32324
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReus_b[5];

32325
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

32326
            _ssSetInputPortNumDimensions(childS, 1, 1);

32327
            ssSetInputPortWidth(childS, 1, 1);

32328
          }

32329


32330
          /* port 2 */

32331
          {

32332
            real32_T const **sfcnUPtrs = (real32_T const **)

32333
              malloc(1 * sizeof(real32_T *));

32334
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32335
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;

32336
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

32337
            _ssSetInputPortNumDimensions(childS, 2, 1);

32338
            ssSetInputPortWidth(childS, 2, 1);

32339
          }

32340


32341
          /* port 3 */

32342
          {

32343
            real32_T const **sfcnUPtrs = (real32_T const **)

32344
              malloc(1 * sizeof(real32_T *));

32345
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32346
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32347
              ssGetLocalBlockIO(rts))->dtCAS;

32348
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

32349
            _ssSetInputPortNumDimensions(childS, 3, 1);

32350
            ssSetInputPortWidth(childS, 3, 1);

32351
          }

32352


32353
          /* port 4 */

32354
          {

32355
            real32_T const **sfcnUPtrs = (real32_T const **)

32356
              malloc(1 * sizeof(real32_T *));

32357
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32358
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32359
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_oi;

32360
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

32361
            _ssSetInputPortNumDimensions(childS, 4, 1);

32362
            ssSetInputPortWidth(childS, 4, 1);

32363
          }

32364
        }

32365


32366
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

32367
          RegNumOutputPorts);

32368
        ssSetRegNumOutputPortsFcnArg(childS,childS);

32369


32370
        /* outputs */

32371
        {

32372
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

32373
            calloc(2, sizeof(struct _ssPortOutputs));

32374
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

32375
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

32376
          _ssSetNumOutputPorts(childS, 2);

32377


32378
          /* port 0 */

32379
          {

32380
            _ssSetOutputPortNumDimensions(childS, 0, 1);

32381
            ssSetOutputPortWidth(childS, 0, 1);

32382
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

32383
              ssGetLocalBlockIO(rts))->GeneratedSFunction_o1));

32384
          }

32385


32386
          /* port 1 */

32387
          {

32388
            _ssSetOutputPortNumDimensions(childS, 1, 1);

32389
            ssSetOutputPortWidth(childS, 1, 1);

32390
            _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)

32391
              ssGetLocalBlockIO(rts))->GeneratedSFunction_o2));

32392
          }

32393
        }

32394


32395
        /* path info */

32396
        _ssSetModelName(childS, "RateLimiter_sf");

32397
        _ssSetPath(childS,

32398
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/Rate Limiter/Generated S-Function");

32399
        if (ssGetRTModel(rts) == (NULL)) {

32400
          _ssSetParentSS(childS, rts);

32401
          _ssSetRootSS(childS, ssGetRootSS(rts));

32402
        } else {

32403
          ssSetRTModel(childS,ssGetRTModel(rts));

32404
          _ssSetParentSS(childS, (NULL));

32405
          _ssSetRootSS(childS, childS);

32406
        }

32407


32408
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

32409


32410
        /* work vectors */

32411
        {

32412
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

32413
            (3 * sizeof(struct _ssDWorkRecord));

32414
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

32415
            calloc(3, sizeof(struct _ssDWorkAuxRecord));

32416
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

32417
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

32418
          ssSetSFcnDWork(childS, dWorkRecord);

32419
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

32420
          _ssSetNumDWork(childS, 3);

32421


32422
          /* DWORK0 */

32423
          ssSetDWorkWidth(childS, 0, 1);

32424
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

32425
          ssSetDWorkComplexSignal(childS, 0, 0);

32426
          ssSetDWorkUsedAsDState(childS, 0, 1);

32427
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 240))[0]);

32428


32429
          /* DWORK1 */

32430
          ssSetDWorkWidth(childS, 1, 1);

32431
          ssSetDWorkDataType(childS, 1,SS_INT8);

32432
          ssSetDWorkComplexSignal(childS, 1, 0);

32433
          ssSetDWorkUsedAsDState(childS, 1, 1);

32434
          _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 467))[0]);

32435


32436
          /* DWORK2 */

32437
          ssSetDWorkWidth(childS, 2, 1);

32438
          ssSetDWorkDataType(childS, 2,SS_INT8);

32439
          ssSetDWorkComplexSignal(childS, 2, 0);

32440
          ssSetDWorkUsedAsDState(childS, 2, 1);

32441
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 468))[0]);

32442
        }

32443


32444
        (childS)->regDataType.arg1 = ((void *)(childS));

32445
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

32446
          FcnSetErrorStatus);

32447
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

32448
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

32449
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

32450
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

32451


32452
        /* registration */

32453
#if defined(MATLAB_MEX_FILE)

32454


32455
        {

32456
          int_T i;

32457
          mxArray *plhs[1];

32458
          mxArray *prhs[4];

32459
          double *pr;

32460
          volatile int_T *intS = (int_T *)&childS;

32461
          int_T addrlen = sizeof(SimStruct *);

32462
          int_T m = addrlen/sizeof(int_T) + 1;

32463
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

32464
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

32465
          pr = mxGetPr(prhs[1]);

32466
          for (i = 0; i < m - 1; i++) {

32467
            pr[i] = (double)intS[i];

32468
          }

32469


32470
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

32471
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

32472
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

32473


32474
          /* Reset port dimensions info functions because the S-function

32475
           * and accelerator mex-files explicitly set their dimensions,

32476
           * i.e., they are not dynamically sized. For this case, the

32477
           * mex-file is responsible for the dimensions info memory

32478
           * and Simulink should not free it. This is achieved by

32479
           * setting the following two methods to NULL.

32480
           */

32481
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

32482
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

32483


32484
          /*

32485
           * Setup function pointers and call mdlInitializeSizes via

32486
           * simulink.c

32487
           */

32488
          mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");

32489
          mxDestroyArray(plhs[0]);

32490
          mxDestroyArray(prhs[0]);

32491
          mxDestroyArray(prhs[1]);

32492
          mxDestroyArray(prhs[2]);

32493
          mxDestroyArray(prhs[3]);

32494
        }

32495


32496
#else

32497


32498
        {

32499
          RateLimiter_sf(childS);

32500
          sfcnInitializeSizes(childS);

32501
        }

32502


32503
#endif

32504


32505
        sfcnInitializeSampleTimes(childS);

32506


32507
        /* adjust sample time */

32508
        ssSetSampleTime(childS, 0, 0.0);

32509
        ssSetOffsetTime(childS, 0, 0.0);

32510
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

32511


32512
        /* set compiled values of dynamic vector attributes */

32513
        ssSetNumNonsampledZCs(childS, 0);

32514


32515
        /* Update connectivity flags for each port */

32516
        _ssSetInputPortConnected(childS, 0, 1);

32517
        _ssSetInputPortConnected(childS, 1, 1);

32518
        _ssSetInputPortConnected(childS, 2, 1);

32519
        _ssSetInputPortConnected(childS, 3, 1);

32520
        _ssSetInputPortConnected(childS, 4, 1);

32521
        _ssSetOutputPortConnected(childS, 0, 1);

32522
        _ssSetOutputPortConnected(childS, 1, 1);

32523
        _ssSetOutputPortBeingMerged(childS, 0, 0);

32524
        _ssSetOutputPortBeingMerged(childS, 1, 0);

32525


32526
        /* Update the BufferDstPort flags for each input port */

32527
        _ssSetInputPortBufferDstPort(childS, 0, -1);

32528
        _ssSetInputPortBufferDstPort(childS, 1, -1);

32529
        _ssSetInputPortBufferDstPort(childS, 2, -1);

32530
        _ssSetInputPortBufferDstPort(childS, 3, -1);

32531
        _ssSetInputPortBufferDstPort(childS, 4, -1);

32532
      }

32533


32534
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S241>/Generated S-Function4 (LagFilter_sf) */

32535
      {

32536
        SimStruct *childS = ssGetSFunction(rts, 123);

32537


32538
        /* timing info */

32539
        time_T *sfcnPeriod;

32540
        time_T *sfcnOffset;

32541
        int_T *sfcnTsMap;

32542
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

32543
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

32544
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

32545
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

32546
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

32547
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

32548
        (void) memset((void*)sfcnPeriod, 0,

32549
                      sizeof(time_T)*1);

32550
        (void) memset((void*)sfcnOffset, 0,

32551
                      sizeof(time_T)*1);

32552
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

32553
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

32554
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

32555


32556
        /* Set up the mdlInfo pointer */

32557
# ifdef USE_RTMODEL

32558


32559
        {

32560
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

32561
              struct _ssBlkInfo2));

32562
          ss_VALIDATE_MEMORY(rts,blkInfo2);

32563
          ssSetBlkInfo2Ptr(childS, blkInfo2);

32564
        }

32565


32566
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

32567


32568
# else

32569


32570
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

32571


32572
# endif                                /* USE_RTMODEL */

32573


32574
        /* Allocate memory of model methods 2 */

32575
        {

32576
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

32577
            malloc(sizeof(struct _ssSFcnModelMethods2));

32578
          ss_VALIDATE_MEMORY(rts,methods2);

32579
          ssSetModelMethods2(childS, methods2);

32580
        }

32581


32582
        /* Allocate memory of model methods 3 */

32583
        {

32584
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

32585
            malloc(sizeof(struct _ssSFcnModelMethods3));

32586
          ss_VALIDATE_MEMORY(rts,methods3);

32587
          ssSetModelMethods3(childS, methods3);

32588
        }

32589


32590
        /* Allocate memory for states auxilliary information */

32591
        {

32592
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

32593
            (sizeof(struct _ssStatesInfo2));

32594
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

32595
            malloc(sizeof(ssPeriodicStatesInfo));

32596
          ss_VALIDATE_MEMORY(rts,statesInfo2);

32597
          ssSetStatesInfo2(childS, statesInfo2);

32598
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

32599
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

32600
        }

32601


32602
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

32603
          RegNumInputPorts);

32604
        ssSetRegNumInputPortsFcnArg(childS,childS);

32605


32606
        /* inputs */

32607
        {

32608
          struct _ssPortInputs *inputPortInfo =

32609
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

32610
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

32611
          _ssSetNumInputPorts(childS, 6);

32612
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

32613


32614
          /* port 0 */

32615
          {

32616
            real32_T const **sfcnUPtrs = (real32_T const **)

32617
              malloc(1 * sizeof(real32_T *));

32618
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32619
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32620
              ssGetLocalBlockIO(rts))->dtCAS;

32621
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

32622
            _ssSetInputPortNumDimensions(childS, 0, 1);

32623
            ssSetInputPortWidth(childS, 0, 1);

32624
          }

32625


32626
          /* port 1 */

32627
          {

32628
            int8_T const **sfcnUPtrs = (int8_T const **)

32629
              malloc(1 * sizeof(int8_T *));

32630
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32631
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

32632
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

32633
            _ssSetInputPortNumDimensions(childS, 1, 1);

32634
            ssSetInputPortWidth(childS, 1, 1);

32635
          }

32636


32637
          /* port 2 */

32638
          {

32639
            real32_T const **sfcnUPtrs = (real32_T const **)

32640
              malloc(1 * sizeof(real32_T *));

32641
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32642
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled126;

32643
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

32644
            _ssSetInputPortNumDimensions(childS, 2, 1);

32645
            ssSetInputPortWidth(childS, 2, 1);

32646
          }

32647


32648
          /* port 3 */

32649
          {

32650
            real32_T const **sfcnUPtrs = (real32_T const **)

32651
              malloc(1 * sizeof(real32_T *));

32652
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32653
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32654
              ssGetLocalBlockIO(rts))->Saturation_ll;

32655
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

32656
            _ssSetInputPortNumDimensions(childS, 3, 1);

32657
            ssSetInputPortWidth(childS, 3, 1);

32658
          }

32659


32660
          /* port 4 */

32661
          {

32662
            real32_T const **sfcnUPtrs = (real32_T const **)

32663
              malloc(1 * sizeof(real32_T *));

32664
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32665
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32666
              ssGetLocalBlockIO(rts))->Saturation_ll;

32667
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

32668
            _ssSetInputPortNumDimensions(childS, 4, 1);

32669
            ssSetInputPortWidth(childS, 4, 1);

32670
          }

32671


32672
          /* port 5 */

32673
          {

32674
            real32_T const **sfcnUPtrs = (real32_T const **)

32675
              malloc(1 * sizeof(real32_T *));

32676
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32677
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32678
              ssGetLocalBlockIO(rts))->Saturation_ll;

32679
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

32680
            _ssSetInputPortNumDimensions(childS, 5, 1);

32681
            ssSetInputPortWidth(childS, 5, 1);

32682
          }

32683
        }

32684


32685
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

32686
          RegNumOutputPorts);

32687
        ssSetRegNumOutputPortsFcnArg(childS,childS);

32688


32689
        /* outputs */

32690
        {

32691
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

32692
            calloc(1, sizeof(struct _ssPortOutputs));

32693
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

32694
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

32695
          _ssSetNumOutputPorts(childS, 1);

32696


32697
          /* port 0 */

32698
          {

32699
            _ssSetOutputPortNumDimensions(childS, 0, 1);

32700
            ssSetOutputPortWidth(childS, 0, 1);

32701
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

32702
              ssGetLocalBlockIO(rts))->Saturation8));

32703
          }

32704
        }

32705


32706
        /* path info */

32707
        _ssSetModelName(childS, "LagFilter_sf");

32708
        _ssSetPath(childS,

32709
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ lag filter2/Generated S-Function4");

32710
        if (ssGetRTModel(rts) == (NULL)) {

32711
          _ssSetParentSS(childS, rts);

32712
          _ssSetRootSS(childS, ssGetRootSS(rts));

32713
        } else {

32714
          ssSetRTModel(childS,ssGetRTModel(rts));

32715
          _ssSetParentSS(childS, (NULL));

32716
          _ssSetRootSS(childS, childS);

32717
        }

32718


32719
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

32720


32721
        /* work vectors */

32722
        {

32723
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

32724
            (4 * sizeof(struct _ssDWorkRecord));

32725
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

32726
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

32727
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

32728
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

32729
          ssSetSFcnDWork(childS, dWorkRecord);

32730
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

32731
          _ssSetNumDWork(childS, 4);

32732


32733
          /* DWORK0 */

32734
          ssSetDWorkWidth(childS, 0, 1);

32735
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

32736
          ssSetDWorkComplexSignal(childS, 0, 0);

32737
          ssSetDWorkUsedAsDState(childS, 0, 1);

32738
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 241))[0]);

32739


32740
          /* DWORK1 */

32741
          ssSetDWorkWidth(childS, 1, 1);

32742
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

32743
          ssSetDWorkComplexSignal(childS, 1, 0);

32744
          ssSetDWorkUsedAsDState(childS, 1, 1);

32745
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 242))[0]);

32746


32747
          /* DWORK2 */

32748
          ssSetDWorkWidth(childS, 2, 1);

32749
          ssSetDWorkDataType(childS, 2,SS_INT8);

32750
          ssSetDWorkComplexSignal(childS, 2, 0);

32751
          ssSetDWorkUsedAsDState(childS, 2, 1);

32752
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 469))[0]);

32753


32754
          /* DWORK3 */

32755
          ssSetDWorkWidth(childS, 3, 1);

32756
          ssSetDWorkDataType(childS, 3,SS_INT8);

32757
          ssSetDWorkComplexSignal(childS, 3, 0);

32758
          ssSetDWorkUsedAsDState(childS, 3, 1);

32759
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 470))[0]);

32760
        }

32761


32762
        (childS)->regDataType.arg1 = ((void *)(childS));

32763
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

32764
          FcnSetErrorStatus);

32765
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

32766
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

32767
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

32768
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

32769


32770
        /* registration */

32771
#if defined(MATLAB_MEX_FILE)

32772


32773
        {

32774
          int_T i;

32775
          mxArray *plhs[1];

32776
          mxArray *prhs[4];

32777
          double *pr;

32778
          volatile int_T *intS = (int_T *)&childS;

32779
          int_T addrlen = sizeof(SimStruct *);

32780
          int_T m = addrlen/sizeof(int_T) + 1;

32781
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

32782
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

32783
          pr = mxGetPr(prhs[1]);

32784
          for (i = 0; i < m - 1; i++) {

32785
            pr[i] = (double)intS[i];

32786
          }

32787


32788
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

32789
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

32790
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

32791


32792
          /* Reset port dimensions info functions because the S-function

32793
           * and accelerator mex-files explicitly set their dimensions,

32794
           * i.e., they are not dynamically sized. For this case, the

32795
           * mex-file is responsible for the dimensions info memory

32796
           * and Simulink should not free it. This is achieved by

32797
           * setting the following two methods to NULL.

32798
           */

32799
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

32800
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

32801


32802
          /*

32803
           * Setup function pointers and call mdlInitializeSizes via

32804
           * simulink.c

32805
           */

32806
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

32807
          mxDestroyArray(plhs[0]);

32808
          mxDestroyArray(prhs[0]);

32809
          mxDestroyArray(prhs[1]);

32810
          mxDestroyArray(prhs[2]);

32811
          mxDestroyArray(prhs[3]);

32812
        }

32813


32814
#else

32815


32816
        {

32817
          LagFilter_sf(childS);

32818
          sfcnInitializeSizes(childS);

32819
        }

32820


32821
#endif

32822


32823
        sfcnInitializeSampleTimes(childS);

32824


32825
        /* adjust sample time */

32826
        ssSetSampleTime(childS, 0, 0.0);

32827
        ssSetOffsetTime(childS, 0, 0.0);

32828
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

32829


32830
        /* set compiled values of dynamic vector attributes */

32831
        ssSetNumNonsampledZCs(childS, 0);

32832


32833
        /* Update connectivity flags for each port */

32834
        _ssSetInputPortConnected(childS, 0, 1);

32835
        _ssSetInputPortConnected(childS, 1, 1);

32836
        _ssSetInputPortConnected(childS, 2, 1);

32837
        _ssSetInputPortConnected(childS, 3, 1);

32838
        _ssSetInputPortConnected(childS, 4, 1);

32839
        _ssSetInputPortConnected(childS, 5, 1);

32840
        _ssSetOutputPortConnected(childS, 0, 1);

32841
        _ssSetOutputPortBeingMerged(childS, 0, 0);

32842


32843
        /* Update the BufferDstPort flags for each input port */

32844
        _ssSetInputPortBufferDstPort(childS, 0, -1);

32845
        _ssSetInputPortBufferDstPort(childS, 1, -1);

32846
        _ssSetInputPortBufferDstPort(childS, 2, -1);

32847
        _ssSetInputPortBufferDstPort(childS, 3, -1);

32848
        _ssSetInputPortBufferDstPort(childS, 4, -1);

32849
        _ssSetInputPortBufferDstPort(childS, 5, -1);

32850
      }

32851


32852
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S245>/Generated S-Function (Gain_sf) */

32853
      {

32854
        SimStruct *childS = ssGetSFunction(rts, 124);

32855


32856
        /* timing info */

32857
        time_T *sfcnPeriod;

32858
        time_T *sfcnOffset;

32859
        int_T *sfcnTsMap;

32860
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

32861
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

32862
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

32863
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

32864
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

32865
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

32866
        (void) memset((void*)sfcnPeriod, 0,

32867
                      sizeof(time_T)*1);

32868
        (void) memset((void*)sfcnOffset, 0,

32869
                      sizeof(time_T)*1);

32870
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

32871
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

32872
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

32873


32874
        /* Set up the mdlInfo pointer */

32875
# ifdef USE_RTMODEL

32876


32877
        {

32878
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

32879
              struct _ssBlkInfo2));

32880
          ss_VALIDATE_MEMORY(rts,blkInfo2);

32881
          ssSetBlkInfo2Ptr(childS, blkInfo2);

32882
        }

32883


32884
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

32885


32886
# else

32887


32888
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

32889


32890
# endif                                /* USE_RTMODEL */

32891


32892
        /* Allocate memory of model methods 2 */

32893
        {

32894
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

32895
            malloc(sizeof(struct _ssSFcnModelMethods2));

32896
          ss_VALIDATE_MEMORY(rts,methods2);

32897
          ssSetModelMethods2(childS, methods2);

32898
        }

32899


32900
        /* Allocate memory of model methods 3 */

32901
        {

32902
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

32903
            malloc(sizeof(struct _ssSFcnModelMethods3));

32904
          ss_VALIDATE_MEMORY(rts,methods3);

32905
          ssSetModelMethods3(childS, methods3);

32906
        }

32907


32908
        /* Allocate memory for states auxilliary information */

32909
        {

32910
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

32911
            (sizeof(struct _ssStatesInfo2));

32912
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

32913
            malloc(sizeof(ssPeriodicStatesInfo));

32914
          ss_VALIDATE_MEMORY(rts,statesInfo2);

32915
          ssSetStatesInfo2(childS, statesInfo2);

32916
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

32917
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

32918
        }

32919


32920
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

32921
          RegNumInputPorts);

32922
        ssSetRegNumInputPortsFcnArg(childS,childS);

32923


32924
        /* inputs */

32925
        {

32926
          struct _ssPortInputs *inputPortInfo =

32927
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

32928
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

32929
          _ssSetNumInputPorts(childS, 2);

32930
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

32931


32932
          /* port 0 */

32933
          {

32934
            real32_T const **sfcnUPtrs = (real32_T const **)

32935
              malloc(1 * sizeof(real32_T *));

32936
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32937
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32938
              ssGetLocalBlockIO(rts))->Sum_ot;

32939
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

32940
            _ssSetInputPortNumDimensions(childS, 0, 1);

32941
            ssSetInputPortWidth(childS, 0, 1);

32942
          }

32943


32944
          /* port 1 */

32945
          {

32946
            real32_T const **sfcnUPtrs = (real32_T const **)

32947
              malloc(1 * sizeof(real32_T *));

32948
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

32949
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

32950
              ssGetLocalBlockIO(rts))->Product_pf;

32951
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

32952
            _ssSetInputPortNumDimensions(childS, 1, 1);

32953
            ssSetInputPortWidth(childS, 1, 1);

32954
          }

32955
        }

32956


32957
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

32958
          RegNumOutputPorts);

32959
        ssSetRegNumOutputPortsFcnArg(childS,childS);

32960


32961
        /* outputs */

32962
        {

32963
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

32964
            calloc(1, sizeof(struct _ssPortOutputs));

32965
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

32966
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

32967
          _ssSetNumOutputPorts(childS, 1);

32968


32969
          /* port 0 */

32970
          {

32971
            _ssSetOutputPortNumDimensions(childS, 0, 1);

32972
            ssSetOutputPortWidth(childS, 0, 1);

32973
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

32974
              ssGetLocalBlockIO(rts))->GeneratedSFunction_fe));

32975
          }

32976
        }

32977


32978
        /* path info */

32979
        _ssSetModelName(childS, "Gain_sf");

32980
        _ssSetPath(childS,

32981
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain3/Generated S-Function");

32982
        if (ssGetRTModel(rts) == (NULL)) {

32983
          _ssSetParentSS(childS, rts);

32984
          _ssSetRootSS(childS, ssGetRootSS(rts));

32985
        } else {

32986
          ssSetRTModel(childS,ssGetRTModel(rts));

32987
          _ssSetParentSS(childS, (NULL));

32988
          _ssSetRootSS(childS, childS);

32989
        }

32990


32991
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

32992
        (childS)->regDataType.arg1 = ((void *)(childS));

32993
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

32994
          FcnSetErrorStatus);

32995
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

32996
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

32997
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

32998
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

32999


33000
        /* registration */

33001
#if defined(MATLAB_MEX_FILE)

33002


33003
        {

33004
          int_T i;

33005
          mxArray *plhs[1];

33006
          mxArray *prhs[4];

33007
          double *pr;

33008
          volatile int_T *intS = (int_T *)&childS;

33009
          int_T addrlen = sizeof(SimStruct *);

33010
          int_T m = addrlen/sizeof(int_T) + 1;

33011
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

33012
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

33013
          pr = mxGetPr(prhs[1]);

33014
          for (i = 0; i < m - 1; i++) {

33015
            pr[i] = (double)intS[i];

33016
          }

33017


33018
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

33019
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

33020
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

33021


33022
          /* Reset port dimensions info functions because the S-function

33023
           * and accelerator mex-files explicitly set their dimensions,

33024
           * i.e., they are not dynamically sized. For this case, the

33025
           * mex-file is responsible for the dimensions info memory

33026
           * and Simulink should not free it. This is achieved by

33027
           * setting the following two methods to NULL.

33028
           */

33029
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

33030
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

33031


33032
          /*

33033
           * Setup function pointers and call mdlInitializeSizes via

33034
           * simulink.c

33035
           */

33036
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

33037
          mxDestroyArray(plhs[0]);

33038
          mxDestroyArray(prhs[0]);

33039
          mxDestroyArray(prhs[1]);

33040
          mxDestroyArray(prhs[2]);

33041
          mxDestroyArray(prhs[3]);

33042
        }

33043


33044
#else

33045


33046
        {

33047
          Gain_sf(childS);

33048
          sfcnInitializeSizes(childS);

33049
        }

33050


33051
#endif

33052


33053
        sfcnInitializeSampleTimes(childS);

33054


33055
        /* adjust sample time */

33056
        ssSetSampleTime(childS, 0, 0.0);

33057
        ssSetOffsetTime(childS, 0, 0.0);

33058
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

33059


33060
        /* set compiled values of dynamic vector attributes */

33061
        ssSetNumNonsampledZCs(childS, 0);

33062


33063
        /* Update connectivity flags for each port */

33064
        _ssSetInputPortConnected(childS, 0, 1);

33065
        _ssSetInputPortConnected(childS, 1, 1);

33066
        _ssSetOutputPortConnected(childS, 0, 1);

33067
        _ssSetOutputPortBeingMerged(childS, 0, 0);

33068


33069
        /* Update the BufferDstPort flags for each input port */

33070
        _ssSetInputPortBufferDstPort(childS, 0, -1);

33071
        _ssSetInputPortBufferDstPort(childS, 1, -1);

33072
      }

33073


33074
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S246>/Generated S-Function (Gain_sf) */

33075
      {

33076
        SimStruct *childS = ssGetSFunction(rts, 125);

33077


33078
        /* timing info */

33079
        time_T *sfcnPeriod;

33080
        time_T *sfcnOffset;

33081
        int_T *sfcnTsMap;

33082
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

33083
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

33084
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

33085
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

33086
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

33087
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

33088
        (void) memset((void*)sfcnPeriod, 0,

33089
                      sizeof(time_T)*1);

33090
        (void) memset((void*)sfcnOffset, 0,

33091
                      sizeof(time_T)*1);

33092
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

33093
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

33094
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

33095


33096
        /* Set up the mdlInfo pointer */

33097
# ifdef USE_RTMODEL

33098


33099
        {

33100
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

33101
              struct _ssBlkInfo2));

33102
          ss_VALIDATE_MEMORY(rts,blkInfo2);

33103
          ssSetBlkInfo2Ptr(childS, blkInfo2);

33104
        }

33105


33106
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

33107


33108
# else

33109


33110
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

33111


33112
# endif                                /* USE_RTMODEL */

33113


33114
        /* Allocate memory of model methods 2 */

33115
        {

33116
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

33117
            malloc(sizeof(struct _ssSFcnModelMethods2));

33118
          ss_VALIDATE_MEMORY(rts,methods2);

33119
          ssSetModelMethods2(childS, methods2);

33120
        }

33121


33122
        /* Allocate memory of model methods 3 */

33123
        {

33124
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

33125
            malloc(sizeof(struct _ssSFcnModelMethods3));

33126
          ss_VALIDATE_MEMORY(rts,methods3);

33127
          ssSetModelMethods3(childS, methods3);

33128
        }

33129


33130
        /* Allocate memory for states auxilliary information */

33131
        {

33132
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

33133
            (sizeof(struct _ssStatesInfo2));

33134
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

33135
            malloc(sizeof(ssPeriodicStatesInfo));

33136
          ss_VALIDATE_MEMORY(rts,statesInfo2);

33137
          ssSetStatesInfo2(childS, statesInfo2);

33138
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

33139
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

33140
        }

33141


33142
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

33143
          RegNumInputPorts);

33144
        ssSetRegNumInputPortsFcnArg(childS,childS);

33145


33146
        /* inputs */

33147
        {

33148
          struct _ssPortInputs *inputPortInfo =

33149
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

33150
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

33151
          _ssSetNumInputPorts(childS, 2);

33152
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

33153


33154
          /* port 0 */

33155
          {

33156
            real32_T const **sfcnUPtrs = (real32_T const **)

33157
              malloc(1 * sizeof(real32_T *));

33158
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33159
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33160
              ssGetLocalBlockIO(rts))->GeneratedSFunction_fe;

33161
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

33162
            _ssSetInputPortNumDimensions(childS, 0, 1);

33163
            ssSetInputPortWidth(childS, 0, 1);

33164
          }

33165


33166
          /* port 1 */

33167
          {

33168
            real32_T const **sfcnUPtrs = (real32_T const **)

33169
              malloc(1 * sizeof(real32_T *));

33170
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33171
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

33172
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

33173
            _ssSetInputPortNumDimensions(childS, 1, 1);

33174
            ssSetInputPortWidth(childS, 1, 1);

33175
          }

33176
        }

33177


33178
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

33179
          RegNumOutputPorts);

33180
        ssSetRegNumOutputPortsFcnArg(childS,childS);

33181


33182
        /* outputs */

33183
        {

33184
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

33185
            calloc(1, sizeof(struct _ssPortOutputs));

33186
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

33187
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

33188
          _ssSetNumOutputPorts(childS, 1);

33189


33190
          /* port 0 */

33191
          {

33192
            _ssSetOutputPortNumDimensions(childS, 0, 1);

33193
            ssSetOutputPortWidth(childS, 0, 1);

33194
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

33195
              ssGetLocalBlockIO(rts))->GeneratedSFunction_gq));

33196
          }

33197
        }

33198


33199
        /* path info */

33200
        _ssSetModelName(childS, "Gain_sf");

33201
        _ssSetPath(childS,

33202
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain4/Generated S-Function");

33203
        if (ssGetRTModel(rts) == (NULL)) {

33204
          _ssSetParentSS(childS, rts);

33205
          _ssSetRootSS(childS, ssGetRootSS(rts));

33206
        } else {

33207
          ssSetRTModel(childS,ssGetRTModel(rts));

33208
          _ssSetParentSS(childS, (NULL));

33209
          _ssSetRootSS(childS, childS);

33210
        }

33211


33212
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

33213
        (childS)->regDataType.arg1 = ((void *)(childS));

33214
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

33215
          FcnSetErrorStatus);

33216
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

33217
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

33218
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

33219
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

33220


33221
        /* registration */

33222
#if defined(MATLAB_MEX_FILE)

33223


33224
        {

33225
          int_T i;

33226
          mxArray *plhs[1];

33227
          mxArray *prhs[4];

33228
          double *pr;

33229
          volatile int_T *intS = (int_T *)&childS;

33230
          int_T addrlen = sizeof(SimStruct *);

33231
          int_T m = addrlen/sizeof(int_T) + 1;

33232
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

33233
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

33234
          pr = mxGetPr(prhs[1]);

33235
          for (i = 0; i < m - 1; i++) {

33236
            pr[i] = (double)intS[i];

33237
          }

33238


33239
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

33240
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

33241
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

33242


33243
          /* Reset port dimensions info functions because the S-function

33244
           * and accelerator mex-files explicitly set their dimensions,

33245
           * i.e., they are not dynamically sized. For this case, the

33246
           * mex-file is responsible for the dimensions info memory

33247
           * and Simulink should not free it. This is achieved by

33248
           * setting the following two methods to NULL.

33249
           */

33250
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

33251
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

33252


33253
          /*

33254
           * Setup function pointers and call mdlInitializeSizes via

33255
           * simulink.c

33256
           */

33257
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

33258
          mxDestroyArray(plhs[0]);

33259
          mxDestroyArray(prhs[0]);

33260
          mxDestroyArray(prhs[1]);

33261
          mxDestroyArray(prhs[2]);

33262
          mxDestroyArray(prhs[3]);

33263
        }

33264


33265
#else

33266


33267
        {

33268
          Gain_sf(childS);

33269
          sfcnInitializeSizes(childS);

33270
        }

33271


33272
#endif

33273


33274
        sfcnInitializeSampleTimes(childS);

33275


33276
        /* adjust sample time */

33277
        ssSetSampleTime(childS, 0, 0.0);

33278
        ssSetOffsetTime(childS, 0, 0.0);

33279
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

33280


33281
        /* set compiled values of dynamic vector attributes */

33282
        ssSetNumNonsampledZCs(childS, 0);

33283


33284
        /* Update connectivity flags for each port */

33285
        _ssSetInputPortConnected(childS, 0, 1);

33286
        _ssSetInputPortConnected(childS, 1, 1);

33287
        _ssSetOutputPortConnected(childS, 0, 1);

33288
        _ssSetOutputPortBeingMerged(childS, 0, 0);

33289


33290
        /* Update the BufferDstPort flags for each input port */

33291
        _ssSetInputPortBufferDstPort(childS, 0, -1);

33292
        _ssSetInputPortBufferDstPort(childS, 1, -1);

33293
      }

33294


33295
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S239>/Generated S-Function4 (LagFilter_sf) */

33296
      {

33297
        SimStruct *childS = ssGetSFunction(rts, 126);

33298


33299
        /* timing info */

33300
        time_T *sfcnPeriod;

33301
        time_T *sfcnOffset;

33302
        int_T *sfcnTsMap;

33303
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

33304
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

33305
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

33306
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

33307
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

33308
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

33309
        (void) memset((void*)sfcnPeriod, 0,

33310
                      sizeof(time_T)*1);

33311
        (void) memset((void*)sfcnOffset, 0,

33312
                      sizeof(time_T)*1);

33313
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

33314
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

33315
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

33316


33317
        /* Set up the mdlInfo pointer */

33318
# ifdef USE_RTMODEL

33319


33320
        {

33321
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

33322
              struct _ssBlkInfo2));

33323
          ss_VALIDATE_MEMORY(rts,blkInfo2);

33324
          ssSetBlkInfo2Ptr(childS, blkInfo2);

33325
        }

33326


33327
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

33328


33329
# else

33330


33331
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

33332


33333
# endif                                /* USE_RTMODEL */

33334


33335
        /* Allocate memory of model methods 2 */

33336
        {

33337
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

33338
            malloc(sizeof(struct _ssSFcnModelMethods2));

33339
          ss_VALIDATE_MEMORY(rts,methods2);

33340
          ssSetModelMethods2(childS, methods2);

33341
        }

33342


33343
        /* Allocate memory of model methods 3 */

33344
        {

33345
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

33346
            malloc(sizeof(struct _ssSFcnModelMethods3));

33347
          ss_VALIDATE_MEMORY(rts,methods3);

33348
          ssSetModelMethods3(childS, methods3);

33349
        }

33350


33351
        /* Allocate memory for states auxilliary information */

33352
        {

33353
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

33354
            (sizeof(struct _ssStatesInfo2));

33355
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

33356
            malloc(sizeof(ssPeriodicStatesInfo));

33357
          ss_VALIDATE_MEMORY(rts,statesInfo2);

33358
          ssSetStatesInfo2(childS, statesInfo2);

33359
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

33360
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

33361
        }

33362


33363
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

33364
          RegNumInputPorts);

33365
        ssSetRegNumInputPortsFcnArg(childS,childS);

33366


33367
        /* inputs */

33368
        {

33369
          struct _ssPortInputs *inputPortInfo =

33370
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

33371
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

33372
          _ssSetNumInputPorts(childS, 6);

33373
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

33374


33375
          /* port 0 */

33376
          {

33377
            real32_T const **sfcnUPtrs = (real32_T const **)

33378
              malloc(1 * sizeof(real32_T *));

33379
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33380
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33381
              ssGetLocalBlockIO(rts))->dtCAS;

33382
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

33383
            _ssSetInputPortNumDimensions(childS, 0, 1);

33384
            ssSetInputPortWidth(childS, 0, 1);

33385
          }

33386


33387
          /* port 1 */

33388
          {

33389
            int8_T const **sfcnUPtrs = (int8_T const **)

33390
              malloc(1 * sizeof(int8_T *));

33391
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33392
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

33393
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

33394
            _ssSetInputPortNumDimensions(childS, 1, 1);

33395
            ssSetInputPortWidth(childS, 1, 1);

33396
          }

33397


33398
          /* port 2 */

33399
          {

33400
            real32_T const **sfcnUPtrs = (real32_T const **)

33401
              malloc(1 * sizeof(real32_T *));

33402
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33403
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

33404
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

33405
            _ssSetInputPortNumDimensions(childS, 2, 1);

33406
            ssSetInputPortWidth(childS, 2, 1);

33407
          }

33408


33409
          /* port 3 */

33410
          {

33411
            real32_T const **sfcnUPtrs = (real32_T const **)

33412
              malloc(1 * sizeof(real32_T *));

33413
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33414
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33415
              ssGetLocalBlockIO(rts))->Ny;

33416
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

33417
            _ssSetInputPortNumDimensions(childS, 3, 1);

33418
            ssSetInputPortWidth(childS, 3, 1);

33419
          }

33420


33421
          /* port 4 */

33422
          {

33423
            real32_T const **sfcnUPtrs = (real32_T const **)

33424
              malloc(1 * sizeof(real32_T *));

33425
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33426
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33427
              ssGetLocalBlockIO(rts))->Ny;

33428
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

33429
            _ssSetInputPortNumDimensions(childS, 4, 1);

33430
            ssSetInputPortWidth(childS, 4, 1);

33431
          }

33432


33433
          /* port 5 */

33434
          {

33435
            real32_T const **sfcnUPtrs = (real32_T const **)

33436
              malloc(1 * sizeof(real32_T *));

33437
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33438
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33439
              ssGetLocalBlockIO(rts))->Ny;

33440
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

33441
            _ssSetInputPortNumDimensions(childS, 5, 1);

33442
            ssSetInputPortWidth(childS, 5, 1);

33443
          }

33444
        }

33445


33446
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

33447
          RegNumOutputPorts);

33448
        ssSetRegNumOutputPortsFcnArg(childS,childS);

33449


33450
        /* outputs */

33451
        {

33452
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

33453
            calloc(1, sizeof(struct _ssPortOutputs));

33454
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

33455
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

33456
          _ssSetNumOutputPorts(childS, 1);

33457


33458
          /* port 0 */

33459
          {

33460
            _ssSetOutputPortNumDimensions(childS, 0, 1);

33461
            ssSetOutputPortWidth(childS, 0, 1);

33462
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

33463
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_kq));

33464
          }

33465
        }

33466


33467
        /* path info */

33468
        _ssSetModelName(childS, "LagFilter_sf");

33469
        _ssSetPath(childS,

33470
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ lag filter/Generated S-Function4");

33471
        if (ssGetRTModel(rts) == (NULL)) {

33472
          _ssSetParentSS(childS, rts);

33473
          _ssSetRootSS(childS, ssGetRootSS(rts));

33474
        } else {

33475
          ssSetRTModel(childS,ssGetRTModel(rts));

33476
          _ssSetParentSS(childS, (NULL));

33477
          _ssSetRootSS(childS, childS);

33478
        }

33479


33480
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

33481


33482
        /* work vectors */

33483
        {

33484
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

33485
            (4 * sizeof(struct _ssDWorkRecord));

33486
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

33487
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

33488
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

33489
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

33490
          ssSetSFcnDWork(childS, dWorkRecord);

33491
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

33492
          _ssSetNumDWork(childS, 4);

33493


33494
          /* DWORK0 */

33495
          ssSetDWorkWidth(childS, 0, 1);

33496
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

33497
          ssSetDWorkComplexSignal(childS, 0, 0);

33498
          ssSetDWorkUsedAsDState(childS, 0, 1);

33499
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 243))[0]);

33500


33501
          /* DWORK1 */

33502
          ssSetDWorkWidth(childS, 1, 1);

33503
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

33504
          ssSetDWorkComplexSignal(childS, 1, 0);

33505
          ssSetDWorkUsedAsDState(childS, 1, 1);

33506
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 244))[0]);

33507


33508
          /* DWORK2 */

33509
          ssSetDWorkWidth(childS, 2, 1);

33510
          ssSetDWorkDataType(childS, 2,SS_INT8);

33511
          ssSetDWorkComplexSignal(childS, 2, 0);

33512
          ssSetDWorkUsedAsDState(childS, 2, 1);

33513
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 471))[0]);

33514


33515
          /* DWORK3 */

33516
          ssSetDWorkWidth(childS, 3, 1);

33517
          ssSetDWorkDataType(childS, 3,SS_INT8);

33518
          ssSetDWorkComplexSignal(childS, 3, 0);

33519
          ssSetDWorkUsedAsDState(childS, 3, 1);

33520
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 472))[0]);

33521
        }

33522


33523
        (childS)->regDataType.arg1 = ((void *)(childS));

33524
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

33525
          FcnSetErrorStatus);

33526
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

33527
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

33528
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

33529
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

33530


33531
        /* registration */

33532
#if defined(MATLAB_MEX_FILE)

33533


33534
        {

33535
          int_T i;

33536
          mxArray *plhs[1];

33537
          mxArray *prhs[4];

33538
          double *pr;

33539
          volatile int_T *intS = (int_T *)&childS;

33540
          int_T addrlen = sizeof(SimStruct *);

33541
          int_T m = addrlen/sizeof(int_T) + 1;

33542
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

33543
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

33544
          pr = mxGetPr(prhs[1]);

33545
          for (i = 0; i < m - 1; i++) {

33546
            pr[i] = (double)intS[i];

33547
          }

33548


33549
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

33550
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

33551
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

33552


33553
          /* Reset port dimensions info functions because the S-function

33554
           * and accelerator mex-files explicitly set their dimensions,

33555
           * i.e., they are not dynamically sized. For this case, the

33556
           * mex-file is responsible for the dimensions info memory

33557
           * and Simulink should not free it. This is achieved by

33558
           * setting the following two methods to NULL.

33559
           */

33560
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

33561
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

33562


33563
          /*

33564
           * Setup function pointers and call mdlInitializeSizes via

33565
           * simulink.c

33566
           */

33567
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

33568
          mxDestroyArray(plhs[0]);

33569
          mxDestroyArray(prhs[0]);

33570
          mxDestroyArray(prhs[1]);

33571
          mxDestroyArray(prhs[2]);

33572
          mxDestroyArray(prhs[3]);

33573
        }

33574


33575
#else

33576


33577
        {

33578
          LagFilter_sf(childS);

33579
          sfcnInitializeSizes(childS);

33580
        }

33581


33582
#endif

33583


33584
        sfcnInitializeSampleTimes(childS);

33585


33586
        /* adjust sample time */

33587
        ssSetSampleTime(childS, 0, 0.0);

33588
        ssSetOffsetTime(childS, 0, 0.0);

33589
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

33590


33591
        /* set compiled values of dynamic vector attributes */

33592
        ssSetNumNonsampledZCs(childS, 0);

33593


33594
        /* Update connectivity flags for each port */

33595
        _ssSetInputPortConnected(childS, 0, 1);

33596
        _ssSetInputPortConnected(childS, 1, 1);

33597
        _ssSetInputPortConnected(childS, 2, 1);

33598
        _ssSetInputPortConnected(childS, 3, 1);

33599
        _ssSetInputPortConnected(childS, 4, 1);

33600
        _ssSetInputPortConnected(childS, 5, 1);

33601
        _ssSetOutputPortConnected(childS, 0, 1);

33602
        _ssSetOutputPortBeingMerged(childS, 0, 0);

33603


33604
        /* Update the BufferDstPort flags for each input port */

33605
        _ssSetInputPortBufferDstPort(childS, 0, -1);

33606
        _ssSetInputPortBufferDstPort(childS, 1, -1);

33607
        _ssSetInputPortBufferDstPort(childS, 2, -1);

33608
        _ssSetInputPortBufferDstPort(childS, 3, -1);

33609
        _ssSetInputPortBufferDstPort(childS, 4, -1);

33610
        _ssSetInputPortBufferDstPort(childS, 5, -1);

33611
      }

33612


33613
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S242>/Generated S-Function (Gain_sf) */

33614
      {

33615
        SimStruct *childS = ssGetSFunction(rts, 127);

33616


33617
        /* timing info */

33618
        time_T *sfcnPeriod;

33619
        time_T *sfcnOffset;

33620
        int_T *sfcnTsMap;

33621
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

33622
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

33623
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

33624
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

33625
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

33626
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

33627
        (void) memset((void*)sfcnPeriod, 0,

33628
                      sizeof(time_T)*1);

33629
        (void) memset((void*)sfcnOffset, 0,

33630
                      sizeof(time_T)*1);

33631
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

33632
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

33633
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

33634


33635
        /* Set up the mdlInfo pointer */

33636
# ifdef USE_RTMODEL

33637


33638
        {

33639
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

33640
              struct _ssBlkInfo2));

33641
          ss_VALIDATE_MEMORY(rts,blkInfo2);

33642
          ssSetBlkInfo2Ptr(childS, blkInfo2);

33643
        }

33644


33645
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

33646


33647
# else

33648


33649
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

33650


33651
# endif                                /* USE_RTMODEL */

33652


33653
        /* Allocate memory of model methods 2 */

33654
        {

33655
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

33656
            malloc(sizeof(struct _ssSFcnModelMethods2));

33657
          ss_VALIDATE_MEMORY(rts,methods2);

33658
          ssSetModelMethods2(childS, methods2);

33659
        }

33660


33661
        /* Allocate memory of model methods 3 */

33662
        {

33663
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

33664
            malloc(sizeof(struct _ssSFcnModelMethods3));

33665
          ss_VALIDATE_MEMORY(rts,methods3);

33666
          ssSetModelMethods3(childS, methods3);

33667
        }

33668


33669
        /* Allocate memory for states auxilliary information */

33670
        {

33671
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

33672
            (sizeof(struct _ssStatesInfo2));

33673
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

33674
            malloc(sizeof(ssPeriodicStatesInfo));

33675
          ss_VALIDATE_MEMORY(rts,statesInfo2);

33676
          ssSetStatesInfo2(childS, statesInfo2);

33677
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

33678
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

33679
        }

33680


33681
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

33682
          RegNumInputPorts);

33683
        ssSetRegNumInputPortsFcnArg(childS,childS);

33684


33685
        /* inputs */

33686
        {

33687
          struct _ssPortInputs *inputPortInfo =

33688
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

33689
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

33690
          _ssSetNumInputPorts(childS, 2);

33691
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

33692


33693
          /* port 0 */

33694
          {

33695
            real32_T const **sfcnUPtrs = (real32_T const **)

33696
              malloc(1 * sizeof(real32_T *));

33697
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33698
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33699
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_kq;

33700
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

33701
            _ssSetInputPortNumDimensions(childS, 0, 1);

33702
            ssSetInputPortWidth(childS, 0, 1);

33703
          }

33704


33705
          /* port 1 */

33706
          {

33707
            real32_T const **sfcnUPtrs = (real32_T const **)

33708
              malloc(1 * sizeof(real32_T *));

33709
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33710
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;

33711
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

33712
            _ssSetInputPortNumDimensions(childS, 1, 1);

33713
            ssSetInputPortWidth(childS, 1, 1);

33714
          }

33715
        }

33716


33717
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

33718
          RegNumOutputPorts);

33719
        ssSetRegNumOutputPortsFcnArg(childS,childS);

33720


33721
        /* outputs */

33722
        {

33723
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

33724
            calloc(1, sizeof(struct _ssPortOutputs));

33725
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

33726
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

33727
          _ssSetNumOutputPorts(childS, 1);

33728


33729
          /* port 0 */

33730
          {

33731
            _ssSetOutputPortNumDimensions(childS, 0, 1);

33732
            ssSetOutputPortWidth(childS, 0, 1);

33733
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

33734
              ssGetLocalBlockIO(rts))->Saturation8));

33735
          }

33736
        }

33737


33738
        /* path info */

33739
        _ssSetModelName(childS, "Gain_sf");

33740
        _ssSetPath(childS,

33741
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain/Generated S-Function");

33742
        if (ssGetRTModel(rts) == (NULL)) {

33743
          _ssSetParentSS(childS, rts);

33744
          _ssSetRootSS(childS, ssGetRootSS(rts));

33745
        } else {

33746
          ssSetRTModel(childS,ssGetRTModel(rts));

33747
          _ssSetParentSS(childS, (NULL));

33748
          _ssSetRootSS(childS, childS);

33749
        }

33750


33751
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

33752
        (childS)->regDataType.arg1 = ((void *)(childS));

33753
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

33754
          FcnSetErrorStatus);

33755
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

33756
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

33757
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

33758
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

33759


33760
        /* registration */

33761
#if defined(MATLAB_MEX_FILE)

33762


33763
        {

33764
          int_T i;

33765
          mxArray *plhs[1];

33766
          mxArray *prhs[4];

33767
          double *pr;

33768
          volatile int_T *intS = (int_T *)&childS;

33769
          int_T addrlen = sizeof(SimStruct *);

33770
          int_T m = addrlen/sizeof(int_T) + 1;

33771
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

33772
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

33773
          pr = mxGetPr(prhs[1]);

33774
          for (i = 0; i < m - 1; i++) {

33775
            pr[i] = (double)intS[i];

33776
          }

33777


33778
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

33779
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

33780
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

33781


33782
          /* Reset port dimensions info functions because the S-function

33783
           * and accelerator mex-files explicitly set their dimensions,

33784
           * i.e., they are not dynamically sized. For this case, the

33785
           * mex-file is responsible for the dimensions info memory

33786
           * and Simulink should not free it. This is achieved by

33787
           * setting the following two methods to NULL.

33788
           */

33789
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

33790
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

33791


33792
          /*

33793
           * Setup function pointers and call mdlInitializeSizes via

33794
           * simulink.c

33795
           */

33796
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

33797
          mxDestroyArray(plhs[0]);

33798
          mxDestroyArray(prhs[0]);

33799
          mxDestroyArray(prhs[1]);

33800
          mxDestroyArray(prhs[2]);

33801
          mxDestroyArray(prhs[3]);

33802
        }

33803


33804
#else

33805


33806
        {

33807
          Gain_sf(childS);

33808
          sfcnInitializeSizes(childS);

33809
        }

33810


33811
#endif

33812


33813
        sfcnInitializeSampleTimes(childS);

33814


33815
        /* adjust sample time */

33816
        ssSetSampleTime(childS, 0, 0.0);

33817
        ssSetOffsetTime(childS, 0, 0.0);

33818
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

33819


33820
        /* set compiled values of dynamic vector attributes */

33821
        ssSetNumNonsampledZCs(childS, 0);

33822


33823
        /* Update connectivity flags for each port */

33824
        _ssSetInputPortConnected(childS, 0, 1);

33825
        _ssSetInputPortConnected(childS, 1, 1);

33826
        _ssSetOutputPortConnected(childS, 0, 1);

33827
        _ssSetOutputPortBeingMerged(childS, 0, 0);

33828


33829
        /* Update the BufferDstPort flags for each input port */

33830
        _ssSetInputPortBufferDstPort(childS, 0, -1);

33831
        _ssSetInputPortBufferDstPort(childS, 1, -1);

33832
      }

33833


33834
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S240>/Generated S-Function4 (LagFilter_sf) */

33835
      {

33836
        SimStruct *childS = ssGetSFunction(rts, 128);

33837


33838
        /* timing info */

33839
        time_T *sfcnPeriod;

33840
        time_T *sfcnOffset;

33841
        int_T *sfcnTsMap;

33842
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

33843
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

33844
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

33845
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

33846
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

33847
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

33848
        (void) memset((void*)sfcnPeriod, 0,

33849
                      sizeof(time_T)*1);

33850
        (void) memset((void*)sfcnOffset, 0,

33851
                      sizeof(time_T)*1);

33852
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

33853
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

33854
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

33855


33856
        /* Set up the mdlInfo pointer */

33857
# ifdef USE_RTMODEL

33858


33859
        {

33860
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

33861
              struct _ssBlkInfo2));

33862
          ss_VALIDATE_MEMORY(rts,blkInfo2);

33863
          ssSetBlkInfo2Ptr(childS, blkInfo2);

33864
        }

33865


33866
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

33867


33868
# else

33869


33870
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

33871


33872
# endif                                /* USE_RTMODEL */

33873


33874
        /* Allocate memory of model methods 2 */

33875
        {

33876
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

33877
            malloc(sizeof(struct _ssSFcnModelMethods2));

33878
          ss_VALIDATE_MEMORY(rts,methods2);

33879
          ssSetModelMethods2(childS, methods2);

33880
        }

33881


33882
        /* Allocate memory of model methods 3 */

33883
        {

33884
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

33885
            malloc(sizeof(struct _ssSFcnModelMethods3));

33886
          ss_VALIDATE_MEMORY(rts,methods3);

33887
          ssSetModelMethods3(childS, methods3);

33888
        }

33889


33890
        /* Allocate memory for states auxilliary information */

33891
        {

33892
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

33893
            (sizeof(struct _ssStatesInfo2));

33894
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

33895
            malloc(sizeof(ssPeriodicStatesInfo));

33896
          ss_VALIDATE_MEMORY(rts,statesInfo2);

33897
          ssSetStatesInfo2(childS, statesInfo2);

33898
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

33899
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

33900
        }

33901


33902
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

33903
          RegNumInputPorts);

33904
        ssSetRegNumInputPortsFcnArg(childS,childS);

33905


33906
        /* inputs */

33907
        {

33908
          struct _ssPortInputs *inputPortInfo =

33909
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

33910
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

33911
          _ssSetNumInputPorts(childS, 6);

33912
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

33913


33914
          /* port 0 */

33915
          {

33916
            real32_T const **sfcnUPtrs = (real32_T const **)

33917
              malloc(1 * sizeof(real32_T *));

33918
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33919
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33920
              ssGetLocalBlockIO(rts))->dtCAS;

33921
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

33922
            _ssSetInputPortNumDimensions(childS, 0, 1);

33923
            ssSetInputPortWidth(childS, 0, 1);

33924
          }

33925


33926
          /* port 1 */

33927
          {

33928
            int8_T const **sfcnUPtrs = (int8_T const **)

33929
              malloc(1 * sizeof(int8_T *));

33930
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33931
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

33932
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

33933
            _ssSetInputPortNumDimensions(childS, 1, 1);

33934
            ssSetInputPortWidth(childS, 1, 1);

33935
          }

33936


33937
          /* port 2 */

33938
          {

33939
            real32_T const **sfcnUPtrs = (real32_T const **)

33940
              malloc(1 * sizeof(real32_T *));

33941
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33942
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled126;

33943
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

33944
            _ssSetInputPortNumDimensions(childS, 2, 1);

33945
            ssSetInputPortWidth(childS, 2, 1);

33946
          }

33947


33948
          /* port 3 */

33949
          {

33950
            real32_T const **sfcnUPtrs = (real32_T const **)

33951
              malloc(1 * sizeof(real32_T *));

33952
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33953
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33954
              ssGetLocalBlockIO(rts))->Saturation1_o;

33955
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

33956
            _ssSetInputPortNumDimensions(childS, 3, 1);

33957
            ssSetInputPortWidth(childS, 3, 1);

33958
          }

33959


33960
          /* port 4 */

33961
          {

33962
            real32_T const **sfcnUPtrs = (real32_T const **)

33963
              malloc(1 * sizeof(real32_T *));

33964
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33965
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33966
              ssGetLocalBlockIO(rts))->Saturation1_o;

33967
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

33968
            _ssSetInputPortNumDimensions(childS, 4, 1);

33969
            ssSetInputPortWidth(childS, 4, 1);

33970
          }

33971


33972
          /* port 5 */

33973
          {

33974
            real32_T const **sfcnUPtrs = (real32_T const **)

33975
              malloc(1 * sizeof(real32_T *));

33976
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

33977
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

33978
              ssGetLocalBlockIO(rts))->Saturation1_o;

33979
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

33980
            _ssSetInputPortNumDimensions(childS, 5, 1);

33981
            ssSetInputPortWidth(childS, 5, 1);

33982
          }

33983
        }

33984


33985
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

33986
          RegNumOutputPorts);

33987
        ssSetRegNumOutputPortsFcnArg(childS,childS);

33988


33989
        /* outputs */

33990
        {

33991
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

33992
            calloc(1, sizeof(struct _ssPortOutputs));

33993
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

33994
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

33995
          _ssSetNumOutputPorts(childS, 1);

33996


33997
          /* port 0 */

33998
          {

33999
            _ssSetOutputPortNumDimensions(childS, 0, 1);

34000
            ssSetOutputPortWidth(childS, 0, 1);

34001
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

34002
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_ab));

34003
          }

34004
        }

34005


34006
        /* path info */

34007
        _ssSetModelName(childS, "LagFilter_sf");

34008
        _ssSetPath(childS,

34009
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ lag filter1/Generated S-Function4");

34010
        if (ssGetRTModel(rts) == (NULL)) {

34011
          _ssSetParentSS(childS, rts);

34012
          _ssSetRootSS(childS, ssGetRootSS(rts));

34013
        } else {

34014
          ssSetRTModel(childS,ssGetRTModel(rts));

34015
          _ssSetParentSS(childS, (NULL));

34016
          _ssSetRootSS(childS, childS);

34017
        }

34018


34019
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

34020


34021
        /* work vectors */

34022
        {

34023
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

34024
            (4 * sizeof(struct _ssDWorkRecord));

34025
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

34026
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

34027
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

34028
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

34029
          ssSetSFcnDWork(childS, dWorkRecord);

34030
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

34031
          _ssSetNumDWork(childS, 4);

34032


34033
          /* DWORK0 */

34034
          ssSetDWorkWidth(childS, 0, 1);

34035
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

34036
          ssSetDWorkComplexSignal(childS, 0, 0);

34037
          ssSetDWorkUsedAsDState(childS, 0, 1);

34038
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 245))[0]);

34039


34040
          /* DWORK1 */

34041
          ssSetDWorkWidth(childS, 1, 1);

34042
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

34043
          ssSetDWorkComplexSignal(childS, 1, 0);

34044
          ssSetDWorkUsedAsDState(childS, 1, 1);

34045
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 246))[0]);

34046


34047
          /* DWORK2 */

34048
          ssSetDWorkWidth(childS, 2, 1);

34049
          ssSetDWorkDataType(childS, 2,SS_INT8);

34050
          ssSetDWorkComplexSignal(childS, 2, 0);

34051
          ssSetDWorkUsedAsDState(childS, 2, 1);

34052
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 473))[0]);

34053


34054
          /* DWORK3 */

34055
          ssSetDWorkWidth(childS, 3, 1);

34056
          ssSetDWorkDataType(childS, 3,SS_INT8);

34057
          ssSetDWorkComplexSignal(childS, 3, 0);

34058
          ssSetDWorkUsedAsDState(childS, 3, 1);

34059
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 474))[0]);

34060
        }

34061


34062
        (childS)->regDataType.arg1 = ((void *)(childS));

34063
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

34064
          FcnSetErrorStatus);

34065
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

34066
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

34067
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

34068
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

34069


34070
        /* registration */

34071
#if defined(MATLAB_MEX_FILE)

34072


34073
        {

34074
          int_T i;

34075
          mxArray *plhs[1];

34076
          mxArray *prhs[4];

34077
          double *pr;

34078
          volatile int_T *intS = (int_T *)&childS;

34079
          int_T addrlen = sizeof(SimStruct *);

34080
          int_T m = addrlen/sizeof(int_T) + 1;

34081
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

34082
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

34083
          pr = mxGetPr(prhs[1]);

34084
          for (i = 0; i < m - 1; i++) {

34085
            pr[i] = (double)intS[i];

34086
          }

34087


34088
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

34089
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

34090
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

34091


34092
          /* Reset port dimensions info functions because the S-function

34093
           * and accelerator mex-files explicitly set their dimensions,

34094
           * i.e., they are not dynamically sized. For this case, the

34095
           * mex-file is responsible for the dimensions info memory

34096
           * and Simulink should not free it. This is achieved by

34097
           * setting the following two methods to NULL.

34098
           */

34099
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

34100
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

34101


34102
          /*

34103
           * Setup function pointers and call mdlInitializeSizes via

34104
           * simulink.c

34105
           */

34106
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

34107
          mxDestroyArray(plhs[0]);

34108
          mxDestroyArray(prhs[0]);

34109
          mxDestroyArray(prhs[1]);

34110
          mxDestroyArray(prhs[2]);

34111
          mxDestroyArray(prhs[3]);

34112
        }

34113


34114
#else

34115


34116
        {

34117
          LagFilter_sf(childS);

34118
          sfcnInitializeSizes(childS);

34119
        }

34120


34121
#endif

34122


34123
        sfcnInitializeSampleTimes(childS);

34124


34125
        /* adjust sample time */

34126
        ssSetSampleTime(childS, 0, 0.0);

34127
        ssSetOffsetTime(childS, 0, 0.0);

34128
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

34129


34130
        /* set compiled values of dynamic vector attributes */

34131
        ssSetNumNonsampledZCs(childS, 0);

34132


34133
        /* Update connectivity flags for each port */

34134
        _ssSetInputPortConnected(childS, 0, 1);

34135
        _ssSetInputPortConnected(childS, 1, 1);

34136
        _ssSetInputPortConnected(childS, 2, 1);

34137
        _ssSetInputPortConnected(childS, 3, 1);

34138
        _ssSetInputPortConnected(childS, 4, 1);

34139
        _ssSetInputPortConnected(childS, 5, 1);

34140
        _ssSetOutputPortConnected(childS, 0, 1);

34141
        _ssSetOutputPortBeingMerged(childS, 0, 0);

34142


34143
        /* Update the BufferDstPort flags for each input port */

34144
        _ssSetInputPortBufferDstPort(childS, 0, -1);

34145
        _ssSetInputPortBufferDstPort(childS, 1, -1);

34146
        _ssSetInputPortBufferDstPort(childS, 2, -1);

34147
        _ssSetInputPortBufferDstPort(childS, 3, -1);

34148
        _ssSetInputPortBufferDstPort(childS, 4, -1);

34149
        _ssSetInputPortBufferDstPort(childS, 5, -1);

34150
      }

34151


34152
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S238>/Generated S-Function8 (WashoutFilter_sf) */

34153
      {

34154
        SimStruct *childS = ssGetSFunction(rts, 129);

34155


34156
        /* timing info */

34157
        time_T *sfcnPeriod;

34158
        time_T *sfcnOffset;

34159
        int_T *sfcnTsMap;

34160
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

34161
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

34162
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

34163
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

34164
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

34165
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

34166
        (void) memset((void*)sfcnPeriod, 0,

34167
                      sizeof(time_T)*1);

34168
        (void) memset((void*)sfcnOffset, 0,

34169
                      sizeof(time_T)*1);

34170
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

34171
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

34172
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

34173


34174
        /* Set up the mdlInfo pointer */

34175
# ifdef USE_RTMODEL

34176


34177
        {

34178
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

34179
              struct _ssBlkInfo2));

34180
          ss_VALIDATE_MEMORY(rts,blkInfo2);

34181
          ssSetBlkInfo2Ptr(childS, blkInfo2);

34182
        }

34183


34184
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

34185


34186
# else

34187


34188
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

34189


34190
# endif                                /* USE_RTMODEL */

34191


34192
        /* Allocate memory of model methods 2 */

34193
        {

34194
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

34195
            malloc(sizeof(struct _ssSFcnModelMethods2));

34196
          ss_VALIDATE_MEMORY(rts,methods2);

34197
          ssSetModelMethods2(childS, methods2);

34198
        }

34199


34200
        /* Allocate memory of model methods 3 */

34201
        {

34202
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

34203
            malloc(sizeof(struct _ssSFcnModelMethods3));

34204
          ss_VALIDATE_MEMORY(rts,methods3);

34205
          ssSetModelMethods3(childS, methods3);

34206
        }

34207


34208
        /* Allocate memory for states auxilliary information */

34209
        {

34210
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

34211
            (sizeof(struct _ssStatesInfo2));

34212
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

34213
            malloc(sizeof(ssPeriodicStatesInfo));

34214
          ss_VALIDATE_MEMORY(rts,statesInfo2);

34215
          ssSetStatesInfo2(childS, statesInfo2);

34216
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

34217
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

34218
        }

34219


34220
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

34221
          RegNumInputPorts);

34222
        ssSetRegNumInputPortsFcnArg(childS,childS);

34223


34224
        /* inputs */

34225
        {

34226
          struct _ssPortInputs *inputPortInfo =

34227
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

34228
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

34229
          _ssSetNumInputPorts(childS, 6);

34230
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

34231


34232
          /* port 0 */

34233
          {

34234
            real32_T const **sfcnUPtrs = (real32_T const **)

34235
              malloc(1 * sizeof(real32_T *));

34236
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34237
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

34238
              ssGetLocalBlockIO(rts))->dtCAS;

34239
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

34240
            _ssSetInputPortNumDimensions(childS, 0, 1);

34241
            ssSetInputPortWidth(childS, 0, 1);

34242
          }

34243


34244
          /* port 1 */

34245
          {

34246
            int8_T const **sfcnUPtrs = (int8_T const **)

34247
              malloc(1 * sizeof(int8_T *));

34248
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34249
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

34250
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

34251
            _ssSetInputPortNumDimensions(childS, 1, 1);

34252
            ssSetInputPortWidth(childS, 1, 1);

34253
          }

34254


34255
          /* port 2 */

34256
          {

34257
            real32_T const **sfcnUPtrs = (real32_T const **)

34258
              malloc(1 * sizeof(real32_T *));

34259
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34260
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

34261
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

34262
            _ssSetInputPortNumDimensions(childS, 2, 1);

34263
            ssSetInputPortWidth(childS, 2, 1);

34264
          }

34265


34266
          /* port 3 */

34267
          {

34268
            real32_T const **sfcnUPtrs = (real32_T const **)

34269
              malloc(1 * sizeof(real32_T *));

34270
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34271
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

34272
              ssGetLocalBlockIO(rts))->Saturation1_o;

34273
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

34274
            _ssSetInputPortNumDimensions(childS, 3, 1);

34275
            ssSetInputPortWidth(childS, 3, 1);

34276
          }

34277


34278
          /* port 4 */

34279
          {

34280
            real32_T const **sfcnUPtrs = (real32_T const **)

34281
              malloc(1 * sizeof(real32_T *));

34282
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34283
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

34284
              ssGetLocalBlockIO(rts))->Saturation1_o;

34285
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

34286
            _ssSetInputPortNumDimensions(childS, 4, 1);

34287
            ssSetInputPortWidth(childS, 4, 1);

34288
          }

34289


34290
          /* port 5 */

34291
          {

34292
            real32_T const **sfcnUPtrs = (real32_T const **)

34293
              malloc(1 * sizeof(real32_T *));

34294
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34295
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

34296
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_ab;

34297
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

34298
            _ssSetInputPortNumDimensions(childS, 5, 1);

34299
            ssSetInputPortWidth(childS, 5, 1);

34300
          }

34301
        }

34302


34303
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

34304
          RegNumOutputPorts);

34305
        ssSetRegNumOutputPortsFcnArg(childS,childS);

34306


34307
        /* outputs */

34308
        {

34309
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

34310
            calloc(1, sizeof(struct _ssPortOutputs));

34311
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

34312
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

34313
          _ssSetNumOutputPorts(childS, 1);

34314


34315
          /* port 0 */

34316
          {

34317
            _ssSetOutputPortNumDimensions(childS, 0, 1);

34318
            ssSetOutputPortWidth(childS, 0, 1);

34319
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

34320
              ssGetLocalBlockIO(rts))->GeneratedSFunction8));

34321
          }

34322
        }

34323


34324
        /* path info */

34325
        _ssSetModelName(childS, "WashoutFilter_sf");

34326
        _ssSetPath(childS,

34327
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ high pass filter/Generated S-Function8");

34328
        if (ssGetRTModel(rts) == (NULL)) {

34329
          _ssSetParentSS(childS, rts);

34330
          _ssSetRootSS(childS, ssGetRootSS(rts));

34331
        } else {

34332
          ssSetRTModel(childS,ssGetRTModel(rts));

34333
          _ssSetParentSS(childS, (NULL));

34334
          _ssSetRootSS(childS, childS);

34335
        }

34336


34337
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

34338


34339
        /* work vectors */

34340
        {

34341
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

34342
            (4 * sizeof(struct _ssDWorkRecord));

34343
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

34344
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

34345
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

34346
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

34347
          ssSetSFcnDWork(childS, dWorkRecord);

34348
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

34349
          _ssSetNumDWork(childS, 4);

34350


34351
          /* DWORK0 */

34352
          ssSetDWorkWidth(childS, 0, 1);

34353
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

34354
          ssSetDWorkComplexSignal(childS, 0, 0);

34355
          ssSetDWorkUsedAsDState(childS, 0, 1);

34356
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 247))[0]);

34357


34358
          /* DWORK1 */

34359
          ssSetDWorkWidth(childS, 1, 1);

34360
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

34361
          ssSetDWorkComplexSignal(childS, 1, 0);

34362
          ssSetDWorkUsedAsDState(childS, 1, 1);

34363
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 248))[0]);

34364


34365
          /* DWORK2 */

34366
          ssSetDWorkWidth(childS, 2, 1);

34367
          ssSetDWorkDataType(childS, 2,SS_INT8);

34368
          ssSetDWorkComplexSignal(childS, 2, 0);

34369
          ssSetDWorkUsedAsDState(childS, 2, 1);

34370
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 475))[0]);

34371


34372
          /* DWORK3 */

34373
          ssSetDWorkWidth(childS, 3, 1);

34374
          ssSetDWorkDataType(childS, 3,SS_INT8);

34375
          ssSetDWorkComplexSignal(childS, 3, 0);

34376
          ssSetDWorkUsedAsDState(childS, 3, 1);

34377
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 476))[0]);

34378
        }

34379


34380
        (childS)->regDataType.arg1 = ((void *)(childS));

34381
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

34382
          FcnSetErrorStatus);

34383
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

34384
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

34385
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

34386
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

34387


34388
        /* registration */

34389
#if defined(MATLAB_MEX_FILE)

34390


34391
        {

34392
          int_T i;

34393
          mxArray *plhs[1];

34394
          mxArray *prhs[4];

34395
          double *pr;

34396
          volatile int_T *intS = (int_T *)&childS;

34397
          int_T addrlen = sizeof(SimStruct *);

34398
          int_T m = addrlen/sizeof(int_T) + 1;

34399
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

34400
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

34401
          pr = mxGetPr(prhs[1]);

34402
          for (i = 0; i < m - 1; i++) {

34403
            pr[i] = (double)intS[i];

34404
          }

34405


34406
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

34407
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

34408
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

34409


34410
          /* Reset port dimensions info functions because the S-function

34411
           * and accelerator mex-files explicitly set their dimensions,

34412
           * i.e., they are not dynamically sized. For this case, the

34413
           * mex-file is responsible for the dimensions info memory

34414
           * and Simulink should not free it. This is achieved by

34415
           * setting the following two methods to NULL.

34416
           */

34417
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

34418
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

34419


34420
          /*

34421
           * Setup function pointers and call mdlInitializeSizes via

34422
           * simulink.c

34423
           */

34424
          mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");

34425
          mxDestroyArray(plhs[0]);

34426
          mxDestroyArray(prhs[0]);

34427
          mxDestroyArray(prhs[1]);

34428
          mxDestroyArray(prhs[2]);

34429
          mxDestroyArray(prhs[3]);

34430
        }

34431


34432
#else

34433


34434
        {

34435
          WashoutFilter_sf(childS);

34436
          sfcnInitializeSizes(childS);

34437
        }

34438


34439
#endif

34440


34441
        sfcnInitializeSampleTimes(childS);

34442


34443
        /* adjust sample time */

34444
        ssSetSampleTime(childS, 0, 0.0);

34445
        ssSetOffsetTime(childS, 0, 0.0);

34446
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

34447


34448
        /* set compiled values of dynamic vector attributes */

34449
        ssSetNumNonsampledZCs(childS, 0);

34450


34451
        /* Update connectivity flags for each port */

34452
        _ssSetInputPortConnected(childS, 0, 1);

34453
        _ssSetInputPortConnected(childS, 1, 1);

34454
        _ssSetInputPortConnected(childS, 2, 1);

34455
        _ssSetInputPortConnected(childS, 3, 1);

34456
        _ssSetInputPortConnected(childS, 4, 1);

34457
        _ssSetInputPortConnected(childS, 5, 1);

34458
        _ssSetOutputPortConnected(childS, 0, 1);

34459
        _ssSetOutputPortBeingMerged(childS, 0, 0);

34460


34461
        /* Update the BufferDstPort flags for each input port */

34462
        _ssSetInputPortBufferDstPort(childS, 0, -1);

34463
        _ssSetInputPortBufferDstPort(childS, 1, -1);

34464
        _ssSetInputPortBufferDstPort(childS, 2, -1);

34465
        _ssSetInputPortBufferDstPort(childS, 3, -1);

34466
        _ssSetInputPortBufferDstPort(childS, 4, -1);

34467
        _ssSetInputPortBufferDstPort(childS, 5, -1);

34468
      }

34469


34470
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S244>/Generated S-Function (Gain_sf) */

34471
      {

34472
        SimStruct *childS = ssGetSFunction(rts, 130);

34473


34474
        /* timing info */

34475
        time_T *sfcnPeriod;

34476
        time_T *sfcnOffset;

34477
        int_T *sfcnTsMap;

34478
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

34479
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

34480
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

34481
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

34482
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

34483
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

34484
        (void) memset((void*)sfcnPeriod, 0,

34485
                      sizeof(time_T)*1);

34486
        (void) memset((void*)sfcnOffset, 0,

34487
                      sizeof(time_T)*1);

34488
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

34489
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

34490
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

34491


34492
        /* Set up the mdlInfo pointer */

34493
# ifdef USE_RTMODEL

34494


34495
        {

34496
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

34497
              struct _ssBlkInfo2));

34498
          ss_VALIDATE_MEMORY(rts,blkInfo2);

34499
          ssSetBlkInfo2Ptr(childS, blkInfo2);

34500
        }

34501


34502
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

34503


34504
# else

34505


34506
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

34507


34508
# endif                                /* USE_RTMODEL */

34509


34510
        /* Allocate memory of model methods 2 */

34511
        {

34512
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

34513
            malloc(sizeof(struct _ssSFcnModelMethods2));

34514
          ss_VALIDATE_MEMORY(rts,methods2);

34515
          ssSetModelMethods2(childS, methods2);

34516
        }

34517


34518
        /* Allocate memory of model methods 3 */

34519
        {

34520
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

34521
            malloc(sizeof(struct _ssSFcnModelMethods3));

34522
          ss_VALIDATE_MEMORY(rts,methods3);

34523
          ssSetModelMethods3(childS, methods3);

34524
        }

34525


34526
        /* Allocate memory for states auxilliary information */

34527
        {

34528
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

34529
            (sizeof(struct _ssStatesInfo2));

34530
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

34531
            malloc(sizeof(ssPeriodicStatesInfo));

34532
          ss_VALIDATE_MEMORY(rts,statesInfo2);

34533
          ssSetStatesInfo2(childS, statesInfo2);

34534
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

34535
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

34536
        }

34537


34538
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

34539
          RegNumInputPorts);

34540
        ssSetRegNumInputPortsFcnArg(childS,childS);

34541


34542
        /* inputs */

34543
        {

34544
          struct _ssPortInputs *inputPortInfo =

34545
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

34546
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

34547
          _ssSetNumInputPorts(childS, 2);

34548
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

34549


34550
          /* port 0 */

34551
          {

34552
            real32_T const **sfcnUPtrs = (real32_T const **)

34553
              malloc(1 * sizeof(real32_T *));

34554
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34555
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

34556
              ssGetLocalBlockIO(rts))->GeneratedSFunction8;

34557
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

34558
            _ssSetInputPortNumDimensions(childS, 0, 1);

34559
            ssSetInputPortWidth(childS, 0, 1);

34560
          }

34561


34562
          /* port 1 */

34563
          {

34564
            real32_T const **sfcnUPtrs = (real32_T const **)

34565
              malloc(1 * sizeof(real32_T *));

34566
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34567
            sfcnUPtrs[0] = (real32_T const *)

34568
              &AFCS_MODEL1_ConstP.Constant23_Value;

34569
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

34570
            _ssSetInputPortNumDimensions(childS, 1, 1);

34571
            ssSetInputPortWidth(childS, 1, 1);

34572
          }

34573
        }

34574


34575
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

34576
          RegNumOutputPorts);

34577
        ssSetRegNumOutputPortsFcnArg(childS,childS);

34578


34579
        /* outputs */

34580
        {

34581
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

34582
            calloc(1, sizeof(struct _ssPortOutputs));

34583
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

34584
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

34585
          _ssSetNumOutputPorts(childS, 1);

34586


34587
          /* port 0 */

34588
          {

34589
            _ssSetOutputPortNumDimensions(childS, 0, 1);

34590
            ssSetOutputPortWidth(childS, 0, 1);

34591
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

34592
              ssGetLocalBlockIO(rts))->MinMax));

34593
          }

34594
        }

34595


34596
        /* path info */

34597
        _ssSetModelName(childS, "Gain_sf");

34598
        _ssSetPath(childS,

34599
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain2/Generated S-Function");

34600
        if (ssGetRTModel(rts) == (NULL)) {

34601
          _ssSetParentSS(childS, rts);

34602
          _ssSetRootSS(childS, ssGetRootSS(rts));

34603
        } else {

34604
          ssSetRTModel(childS,ssGetRTModel(rts));

34605
          _ssSetParentSS(childS, (NULL));

34606
          _ssSetRootSS(childS, childS);

34607
        }

34608


34609
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

34610
        (childS)->regDataType.arg1 = ((void *)(childS));

34611
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

34612
          FcnSetErrorStatus);

34613
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

34614
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

34615
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

34616
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

34617


34618
        /* registration */

34619
#if defined(MATLAB_MEX_FILE)

34620


34621
        {

34622
          int_T i;

34623
          mxArray *plhs[1];

34624
          mxArray *prhs[4];

34625
          double *pr;

34626
          volatile int_T *intS = (int_T *)&childS;

34627
          int_T addrlen = sizeof(SimStruct *);

34628
          int_T m = addrlen/sizeof(int_T) + 1;

34629
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

34630
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

34631
          pr = mxGetPr(prhs[1]);

34632
          for (i = 0; i < m - 1; i++) {

34633
            pr[i] = (double)intS[i];

34634
          }

34635


34636
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

34637
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

34638
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

34639


34640
          /* Reset port dimensions info functions because the S-function

34641
           * and accelerator mex-files explicitly set their dimensions,

34642
           * i.e., they are not dynamically sized. For this case, the

34643
           * mex-file is responsible for the dimensions info memory

34644
           * and Simulink should not free it. This is achieved by

34645
           * setting the following two methods to NULL.

34646
           */

34647
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

34648
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

34649


34650
          /*

34651
           * Setup function pointers and call mdlInitializeSizes via

34652
           * simulink.c

34653
           */

34654
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

34655
          mxDestroyArray(plhs[0]);

34656
          mxDestroyArray(prhs[0]);

34657
          mxDestroyArray(prhs[1]);

34658
          mxDestroyArray(prhs[2]);

34659
          mxDestroyArray(prhs[3]);

34660
        }

34661


34662
#else

34663


34664
        {

34665
          Gain_sf(childS);

34666
          sfcnInitializeSizes(childS);

34667
        }

34668


34669
#endif

34670


34671
        sfcnInitializeSampleTimes(childS);

34672


34673
        /* adjust sample time */

34674
        ssSetSampleTime(childS, 0, 0.0);

34675
        ssSetOffsetTime(childS, 0, 0.0);

34676
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

34677


34678
        /* set compiled values of dynamic vector attributes */

34679
        ssSetNumNonsampledZCs(childS, 0);

34680


34681
        /* Update connectivity flags for each port */

34682
        _ssSetInputPortConnected(childS, 0, 1);

34683
        _ssSetInputPortConnected(childS, 1, 1);

34684
        _ssSetOutputPortConnected(childS, 0, 1);

34685
        _ssSetOutputPortBeingMerged(childS, 0, 0);

34686


34687
        /* Update the BufferDstPort flags for each input port */

34688
        _ssSetInputPortBufferDstPort(childS, 0, -1);

34689
        _ssSetInputPortBufferDstPort(childS, 1, -1);

34690
      }

34691


34692
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S243>/Generated S-Function (Gain_sf) */

34693
      {

34694
        SimStruct *childS = ssGetSFunction(rts, 131);

34695


34696
        /* timing info */

34697
        time_T *sfcnPeriod;

34698
        time_T *sfcnOffset;

34699
        int_T *sfcnTsMap;

34700
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

34701
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

34702
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

34703
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

34704
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

34705
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

34706
        (void) memset((void*)sfcnPeriod, 0,

34707
                      sizeof(time_T)*1);

34708
        (void) memset((void*)sfcnOffset, 0,

34709
                      sizeof(time_T)*1);

34710
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

34711
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

34712
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

34713


34714
        /* Set up the mdlInfo pointer */

34715
# ifdef USE_RTMODEL

34716


34717
        {

34718
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

34719
              struct _ssBlkInfo2));

34720
          ss_VALIDATE_MEMORY(rts,blkInfo2);

34721
          ssSetBlkInfo2Ptr(childS, blkInfo2);

34722
        }

34723


34724
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

34725


34726
# else

34727


34728
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

34729


34730
# endif                                /* USE_RTMODEL */

34731


34732
        /* Allocate memory of model methods 2 */

34733
        {

34734
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

34735
            malloc(sizeof(struct _ssSFcnModelMethods2));

34736
          ss_VALIDATE_MEMORY(rts,methods2);

34737
          ssSetModelMethods2(childS, methods2);

34738
        }

34739


34740
        /* Allocate memory of model methods 3 */

34741
        {

34742
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

34743
            malloc(sizeof(struct _ssSFcnModelMethods3));

34744
          ss_VALIDATE_MEMORY(rts,methods3);

34745
          ssSetModelMethods3(childS, methods3);

34746
        }

34747


34748
        /* Allocate memory for states auxilliary information */

34749
        {

34750
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

34751
            (sizeof(struct _ssStatesInfo2));

34752
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

34753
            malloc(sizeof(ssPeriodicStatesInfo));

34754
          ss_VALIDATE_MEMORY(rts,statesInfo2);

34755
          ssSetStatesInfo2(childS, statesInfo2);

34756
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

34757
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

34758
        }

34759


34760
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

34761
          RegNumInputPorts);

34762
        ssSetRegNumInputPortsFcnArg(childS,childS);

34763


34764
        /* inputs */

34765
        {

34766
          struct _ssPortInputs *inputPortInfo =

34767
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

34768
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

34769
          _ssSetNumInputPorts(childS, 2);

34770
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

34771


34772
          /* port 0 */

34773
          {

34774
            real32_T const **sfcnUPtrs = (real32_T const **)

34775
              malloc(1 * sizeof(real32_T *));

34776
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34777
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

34778
              ssGetLocalBlockIO(rts))->Sum5;

34779
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

34780
            _ssSetInputPortNumDimensions(childS, 0, 1);

34781
            ssSetInputPortWidth(childS, 0, 1);

34782
          }

34783


34784
          /* port 1 */

34785
          {

34786
            real32_T const **sfcnUPtrs = (real32_T const **)

34787
              malloc(1 * sizeof(real32_T *));

34788
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34789
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

34790
              ssGetLocalBlockIO(rts))->Product2_d;

34791
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

34792
            _ssSetInputPortNumDimensions(childS, 1, 1);

34793
            ssSetInputPortWidth(childS, 1, 1);

34794
          }

34795
        }

34796


34797
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

34798
          RegNumOutputPorts);

34799
        ssSetRegNumOutputPortsFcnArg(childS,childS);

34800


34801
        /* outputs */

34802
        {

34803
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

34804
            calloc(1, sizeof(struct _ssPortOutputs));

34805
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

34806
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

34807
          _ssSetNumOutputPorts(childS, 1);

34808


34809
          /* port 0 */

34810
          {

34811
            _ssSetOutputPortNumDimensions(childS, 0, 1);

34812
            ssSetOutputPortWidth(childS, 0, 1);

34813
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

34814
              ssGetLocalBlockIO(rts))->GeneratedSFunction_dc));

34815
          }

34816
        }

34817


34818
        /* path info */

34819
        _ssSetModelName(childS, "Gain_sf");

34820
        _ssSetPath(childS,

34821
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain1/Generated S-Function");

34822
        if (ssGetRTModel(rts) == (NULL)) {

34823
          _ssSetParentSS(childS, rts);

34824
          _ssSetRootSS(childS, ssGetRootSS(rts));

34825
        } else {

34826
          ssSetRTModel(childS,ssGetRTModel(rts));

34827
          _ssSetParentSS(childS, (NULL));

34828
          _ssSetRootSS(childS, childS);

34829
        }

34830


34831
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

34832
        (childS)->regDataType.arg1 = ((void *)(childS));

34833
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

34834
          FcnSetErrorStatus);

34835
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

34836
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

34837
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

34838
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

34839


34840
        /* registration */

34841
#if defined(MATLAB_MEX_FILE)

34842


34843
        {

34844
          int_T i;

34845
          mxArray *plhs[1];

34846
          mxArray *prhs[4];

34847
          double *pr;

34848
          volatile int_T *intS = (int_T *)&childS;

34849
          int_T addrlen = sizeof(SimStruct *);

34850
          int_T m = addrlen/sizeof(int_T) + 1;

34851
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

34852
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

34853
          pr = mxGetPr(prhs[1]);

34854
          for (i = 0; i < m - 1; i++) {

34855
            pr[i] = (double)intS[i];

34856
          }

34857


34858
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

34859
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

34860
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

34861


34862
          /* Reset port dimensions info functions because the S-function

34863
           * and accelerator mex-files explicitly set their dimensions,

34864
           * i.e., they are not dynamically sized. For this case, the

34865
           * mex-file is responsible for the dimensions info memory

34866
           * and Simulink should not free it. This is achieved by

34867
           * setting the following two methods to NULL.

34868
           */

34869
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

34870
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

34871


34872
          /*

34873
           * Setup function pointers and call mdlInitializeSizes via

34874
           * simulink.c

34875
           */

34876
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

34877
          mxDestroyArray(plhs[0]);

34878
          mxDestroyArray(prhs[0]);

34879
          mxDestroyArray(prhs[1]);

34880
          mxDestroyArray(prhs[2]);

34881
          mxDestroyArray(prhs[3]);

34882
        }

34883


34884
#else

34885


34886
        {

34887
          Gain_sf(childS);

34888
          sfcnInitializeSizes(childS);

34889
        }

34890


34891
#endif

34892


34893
        sfcnInitializeSampleTimes(childS);

34894


34895
        /* adjust sample time */

34896
        ssSetSampleTime(childS, 0, 0.0);

34897
        ssSetOffsetTime(childS, 0, 0.0);

34898
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

34899


34900
        /* set compiled values of dynamic vector attributes */

34901
        ssSetNumNonsampledZCs(childS, 0);

34902


34903
        /* Update connectivity flags for each port */

34904
        _ssSetInputPortConnected(childS, 0, 1);

34905
        _ssSetInputPortConnected(childS, 1, 1);

34906
        _ssSetOutputPortConnected(childS, 0, 1);

34907
        _ssSetOutputPortBeingMerged(childS, 0, 0);

34908


34909
        /* Update the BufferDstPort flags for each input port */

34910
        _ssSetInputPortBufferDstPort(childS, 0, -1);

34911
        _ssSetInputPortBufferDstPort(childS, 1, -1);

34912
      }

34913


34914
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S225>/Generated S-Function1 (SaturationLimiter_sf) */

34915
      {

34916
        SimStruct *childS = ssGetSFunction(rts, 132);

34917


34918
        /* timing info */

34919
        time_T *sfcnPeriod;

34920
        time_T *sfcnOffset;

34921
        int_T *sfcnTsMap;

34922
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

34923
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

34924
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

34925
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

34926
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

34927
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

34928
        (void) memset((void*)sfcnPeriod, 0,

34929
                      sizeof(time_T)*1);

34930
        (void) memset((void*)sfcnOffset, 0,

34931
                      sizeof(time_T)*1);

34932
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

34933
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

34934
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

34935


34936
        /* Set up the mdlInfo pointer */

34937
# ifdef USE_RTMODEL

34938


34939
        {

34940
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

34941
              struct _ssBlkInfo2));

34942
          ss_VALIDATE_MEMORY(rts,blkInfo2);

34943
          ssSetBlkInfo2Ptr(childS, blkInfo2);

34944
        }

34945


34946
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

34947


34948
# else

34949


34950
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

34951


34952
# endif                                /* USE_RTMODEL */

34953


34954
        /* Allocate memory of model methods 2 */

34955
        {

34956
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

34957
            malloc(sizeof(struct _ssSFcnModelMethods2));

34958
          ss_VALIDATE_MEMORY(rts,methods2);

34959
          ssSetModelMethods2(childS, methods2);

34960
        }

34961


34962
        /* Allocate memory of model methods 3 */

34963
        {

34964
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

34965
            malloc(sizeof(struct _ssSFcnModelMethods3));

34966
          ss_VALIDATE_MEMORY(rts,methods3);

34967
          ssSetModelMethods3(childS, methods3);

34968
        }

34969


34970
        /* Allocate memory for states auxilliary information */

34971
        {

34972
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

34973
            (sizeof(struct _ssStatesInfo2));

34974
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

34975
            malloc(sizeof(ssPeriodicStatesInfo));

34976
          ss_VALIDATE_MEMORY(rts,statesInfo2);

34977
          ssSetStatesInfo2(childS, statesInfo2);

34978
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

34979
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

34980
        }

34981


34982
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

34983
          RegNumInputPorts);

34984
        ssSetRegNumInputPortsFcnArg(childS,childS);

34985


34986
        /* inputs */

34987
        {

34988
          struct _ssPortInputs *inputPortInfo =

34989
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

34990
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

34991
          _ssSetNumInputPorts(childS, 3);

34992
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

34993


34994
          /* port 0 */

34995
          {

34996
            real32_T const **sfcnUPtrs = (real32_T const **)

34997
              malloc(1 * sizeof(real32_T *));

34998
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

34999
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35000
              ssGetLocalBlockIO(rts))->Switch_dd;

35001
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

35002
            _ssSetInputPortNumDimensions(childS, 0, 1);

35003
            ssSetInputPortWidth(childS, 0, 1);

35004
          }

35005


35006
          /* port 1 */

35007
          {

35008
            real32_T const **sfcnUPtrs = (real32_T const **)

35009
              malloc(1 * sizeof(real32_T *));

35010
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35011
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;

35012
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

35013
            _ssSetInputPortNumDimensions(childS, 1, 1);

35014
            ssSetInputPortWidth(childS, 1, 1);

35015
          }

35016


35017
          /* port 2 */

35018
          {

35019
            real32_T const **sfcnUPtrs = (real32_T const **)

35020
              malloc(1 * sizeof(real32_T *));

35021
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35022
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;

35023
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

35024
            _ssSetInputPortNumDimensions(childS, 2, 1);

35025
            ssSetInputPortWidth(childS, 2, 1);

35026
          }

35027
        }

35028


35029
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

35030
          RegNumOutputPorts);

35031
        ssSetRegNumOutputPortsFcnArg(childS,childS);

35032


35033
        /* outputs */

35034
        {

35035
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

35036
            calloc(1, sizeof(struct _ssPortOutputs));

35037
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

35038
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

35039
          _ssSetNumOutputPorts(childS, 1);

35040


35041
          /* port 0 */

35042
          {

35043
            _ssSetOutputPortNumDimensions(childS, 0, 1);

35044
            ssSetOutputPortWidth(childS, 0, 1);

35045
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

35046
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_en));

35047
          }

35048
        }

35049


35050
        /* path info */

35051
        _ssSetModelName(childS, "SaturationLimiter_sf");

35052
        _ssSetPath(childS,

35053
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Saturation Limiter1/Generated S-Function1");

35054
        if (ssGetRTModel(rts) == (NULL)) {

35055
          _ssSetParentSS(childS, rts);

35056
          _ssSetRootSS(childS, ssGetRootSS(rts));

35057
        } else {

35058
          ssSetRTModel(childS,ssGetRTModel(rts));

35059
          _ssSetParentSS(childS, (NULL));

35060
          _ssSetRootSS(childS, childS);

35061
        }

35062


35063
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

35064
        (childS)->regDataType.arg1 = ((void *)(childS));

35065
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

35066
          FcnSetErrorStatus);

35067
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

35068
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

35069
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

35070
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

35071


35072
        /* registration */

35073
#if defined(MATLAB_MEX_FILE)

35074


35075
        {

35076
          int_T i;

35077
          mxArray *plhs[1];

35078
          mxArray *prhs[4];

35079
          double *pr;

35080
          volatile int_T *intS = (int_T *)&childS;

35081
          int_T addrlen = sizeof(SimStruct *);

35082
          int_T m = addrlen/sizeof(int_T) + 1;

35083
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

35084
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

35085
          pr = mxGetPr(prhs[1]);

35086
          for (i = 0; i < m - 1; i++) {

35087
            pr[i] = (double)intS[i];

35088
          }

35089


35090
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

35091
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

35092
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

35093


35094
          /* Reset port dimensions info functions because the S-function

35095
           * and accelerator mex-files explicitly set their dimensions,

35096
           * i.e., they are not dynamically sized. For this case, the

35097
           * mex-file is responsible for the dimensions info memory

35098
           * and Simulink should not free it. This is achieved by

35099
           * setting the following two methods to NULL.

35100
           */

35101
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

35102
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

35103


35104
          /*

35105
           * Setup function pointers and call mdlInitializeSizes via

35106
           * simulink.c

35107
           */

35108
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

35109
          mxDestroyArray(plhs[0]);

35110
          mxDestroyArray(prhs[0]);

35111
          mxDestroyArray(prhs[1]);

35112
          mxDestroyArray(prhs[2]);

35113
          mxDestroyArray(prhs[3]);

35114
        }

35115


35116
#else

35117


35118
        {

35119
          SaturationLimiter_sf(childS);

35120
          sfcnInitializeSizes(childS);

35121
        }

35122


35123
#endif

35124


35125
        sfcnInitializeSampleTimes(childS);

35126


35127
        /* adjust sample time */

35128
        ssSetSampleTime(childS, 0, 0.0);

35129
        ssSetOffsetTime(childS, 0, 0.0);

35130
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

35131


35132
        /* set compiled values of dynamic vector attributes */

35133
        ssSetNumNonsampledZCs(childS, 0);

35134


35135
        /* Update connectivity flags for each port */

35136
        _ssSetInputPortConnected(childS, 0, 1);

35137
        _ssSetInputPortConnected(childS, 1, 1);

35138
        _ssSetInputPortConnected(childS, 2, 1);

35139
        _ssSetOutputPortConnected(childS, 0, 1);

35140
        _ssSetOutputPortBeingMerged(childS, 0, 0);

35141


35142
        /* Update the BufferDstPort flags for each input port */

35143
        _ssSetInputPortBufferDstPort(childS, 0, -1);

35144
        _ssSetInputPortBufferDstPort(childS, 1, -1);

35145
        _ssSetInputPortBufferDstPort(childS, 2, -1);

35146
      }

35147


35148
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S223>/Generated S-Function7 (RateLimiter_sf) */

35149
      {

35150
        SimStruct *childS = ssGetSFunction(rts, 133);

35151


35152
        /* timing info */

35153
        time_T *sfcnPeriod;

35154
        time_T *sfcnOffset;

35155
        int_T *sfcnTsMap;

35156
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

35157
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

35158
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

35159
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

35160
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

35161
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

35162
        (void) memset((void*)sfcnPeriod, 0,

35163
                      sizeof(time_T)*1);

35164
        (void) memset((void*)sfcnOffset, 0,

35165
                      sizeof(time_T)*1);

35166
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

35167
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

35168
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

35169


35170
        /* Set up the mdlInfo pointer */

35171
# ifdef USE_RTMODEL

35172


35173
        {

35174
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

35175
              struct _ssBlkInfo2));

35176
          ss_VALIDATE_MEMORY(rts,blkInfo2);

35177
          ssSetBlkInfo2Ptr(childS, blkInfo2);

35178
        }

35179


35180
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

35181


35182
# else

35183


35184
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

35185


35186
# endif                                /* USE_RTMODEL */

35187


35188
        /* Allocate memory of model methods 2 */

35189
        {

35190
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

35191
            malloc(sizeof(struct _ssSFcnModelMethods2));

35192
          ss_VALIDATE_MEMORY(rts,methods2);

35193
          ssSetModelMethods2(childS, methods2);

35194
        }

35195


35196
        /* Allocate memory of model methods 3 */

35197
        {

35198
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

35199
            malloc(sizeof(struct _ssSFcnModelMethods3));

35200
          ss_VALIDATE_MEMORY(rts,methods3);

35201
          ssSetModelMethods3(childS, methods3);

35202
        }

35203


35204
        /* Allocate memory for states auxilliary information */

35205
        {

35206
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

35207
            (sizeof(struct _ssStatesInfo2));

35208
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

35209
            malloc(sizeof(ssPeriodicStatesInfo));

35210
          ss_VALIDATE_MEMORY(rts,statesInfo2);

35211
          ssSetStatesInfo2(childS, statesInfo2);

35212
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

35213
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

35214
        }

35215


35216
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

35217
          RegNumInputPorts);

35218
        ssSetRegNumInputPortsFcnArg(childS,childS);

35219


35220
        /* inputs */

35221
        {

35222
          struct _ssPortInputs *inputPortInfo =

35223
            (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));

35224
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

35225
          _ssSetNumInputPorts(childS, 5);

35226
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

35227


35228
          /* port 0 */

35229
          {

35230
            int8_T const **sfcnUPtrs = (int8_T const **)

35231
              malloc(1 * sizeof(int8_T *));

35232
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35233
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

35234
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

35235
            _ssSetInputPortNumDimensions(childS, 0, 1);

35236
            ssSetInputPortWidth(childS, 0, 1);

35237
          }

35238


35239
          /* port 1 */

35240
          {

35241
            real32_T const **sfcnUPtrs = (real32_T const **)

35242
              malloc(1 * sizeof(real32_T *));

35243
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35244
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35245
              ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReus_b[4];

35246
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

35247
            _ssSetInputPortNumDimensions(childS, 1, 1);

35248
            ssSetInputPortWidth(childS, 1, 1);

35249
          }

35250


35251
          /* port 2 */

35252
          {

35253
            real32_T const **sfcnUPtrs = (real32_T const **)

35254
              malloc(1 * sizeof(real32_T *));

35255
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35256
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled125;

35257
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

35258
            _ssSetInputPortNumDimensions(childS, 2, 1);

35259
            ssSetInputPortWidth(childS, 2, 1);

35260
          }

35261


35262
          /* port 3 */

35263
          {

35264
            real32_T const **sfcnUPtrs = (real32_T const **)

35265
              malloc(1 * sizeof(real32_T *));

35266
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35267
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35268
              ssGetLocalBlockIO(rts))->dtCAS;

35269
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

35270
            _ssSetInputPortNumDimensions(childS, 3, 1);

35271
            ssSetInputPortWidth(childS, 3, 1);

35272
          }

35273


35274
          /* port 4 */

35275
          {

35276
            real32_T const **sfcnUPtrs = (real32_T const **)

35277
              malloc(1 * sizeof(real32_T *));

35278
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35279
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35280
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_en;

35281
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

35282
            _ssSetInputPortNumDimensions(childS, 4, 1);

35283
            ssSetInputPortWidth(childS, 4, 1);

35284
          }

35285
        }

35286


35287
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

35288
          RegNumOutputPorts);

35289
        ssSetRegNumOutputPortsFcnArg(childS,childS);

35290


35291
        /* outputs */

35292
        {

35293
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

35294
            calloc(2, sizeof(struct _ssPortOutputs));

35295
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

35296
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

35297
          _ssSetNumOutputPorts(childS, 2);

35298


35299
          /* port 0 */

35300
          {

35301
            _ssSetOutputPortNumDimensions(childS, 0, 1);

35302
            ssSetOutputPortWidth(childS, 0, 1);

35303
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

35304
              ssGetLocalBlockIO(rts))->Saturation8));

35305
          }

35306


35307
          /* port 1 */

35308
          {

35309
            _ssSetOutputPortNumDimensions(childS, 1, 1);

35310
            ssSetOutputPortWidth(childS, 1, 1);

35311
            _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)

35312
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2));

35313
          }

35314
        }

35315


35316
        /* path info */

35317
        _ssSetModelName(childS, "RateLimiter_sf");

35318
        _ssSetPath(childS,

35319
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Rate Limiter1/Generated S-Function7");

35320
        if (ssGetRTModel(rts) == (NULL)) {

35321
          _ssSetParentSS(childS, rts);

35322
          _ssSetRootSS(childS, ssGetRootSS(rts));

35323
        } else {

35324
          ssSetRTModel(childS,ssGetRTModel(rts));

35325
          _ssSetParentSS(childS, (NULL));

35326
          _ssSetRootSS(childS, childS);

35327
        }

35328


35329
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

35330


35331
        /* work vectors */

35332
        {

35333
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

35334
            (3 * sizeof(struct _ssDWorkRecord));

35335
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

35336
            calloc(3, sizeof(struct _ssDWorkAuxRecord));

35337
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

35338
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

35339
          ssSetSFcnDWork(childS, dWorkRecord);

35340
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

35341
          _ssSetNumDWork(childS, 3);

35342


35343
          /* DWORK0 */

35344
          ssSetDWorkWidth(childS, 0, 1);

35345
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

35346
          ssSetDWorkComplexSignal(childS, 0, 0);

35347
          ssSetDWorkUsedAsDState(childS, 0, 1);

35348
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 249))[0]);

35349


35350
          /* DWORK1 */

35351
          ssSetDWorkWidth(childS, 1, 1);

35352
          ssSetDWorkDataType(childS, 1,SS_INT8);

35353
          ssSetDWorkComplexSignal(childS, 1, 0);

35354
          ssSetDWorkUsedAsDState(childS, 1, 1);

35355
          _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 477))[0]);

35356


35357
          /* DWORK2 */

35358
          ssSetDWorkWidth(childS, 2, 1);

35359
          ssSetDWorkDataType(childS, 2,SS_INT8);

35360
          ssSetDWorkComplexSignal(childS, 2, 0);

35361
          ssSetDWorkUsedAsDState(childS, 2, 1);

35362
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 478))[0]);

35363
        }

35364


35365
        (childS)->regDataType.arg1 = ((void *)(childS));

35366
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

35367
          FcnSetErrorStatus);

35368
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

35369
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

35370
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

35371
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

35372


35373
        /* registration */

35374
#if defined(MATLAB_MEX_FILE)

35375


35376
        {

35377
          int_T i;

35378
          mxArray *plhs[1];

35379
          mxArray *prhs[4];

35380
          double *pr;

35381
          volatile int_T *intS = (int_T *)&childS;

35382
          int_T addrlen = sizeof(SimStruct *);

35383
          int_T m = addrlen/sizeof(int_T) + 1;

35384
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

35385
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

35386
          pr = mxGetPr(prhs[1]);

35387
          for (i = 0; i < m - 1; i++) {

35388
            pr[i] = (double)intS[i];

35389
          }

35390


35391
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

35392
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

35393
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

35394


35395
          /* Reset port dimensions info functions because the S-function

35396
           * and accelerator mex-files explicitly set their dimensions,

35397
           * i.e., they are not dynamically sized. For this case, the

35398
           * mex-file is responsible for the dimensions info memory

35399
           * and Simulink should not free it. This is achieved by

35400
           * setting the following two methods to NULL.

35401
           */

35402
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

35403
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

35404


35405
          /*

35406
           * Setup function pointers and call mdlInitializeSizes via

35407
           * simulink.c

35408
           */

35409
          mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");

35410
          mxDestroyArray(plhs[0]);

35411
          mxDestroyArray(prhs[0]);

35412
          mxDestroyArray(prhs[1]);

35413
          mxDestroyArray(prhs[2]);

35414
          mxDestroyArray(prhs[3]);

35415
        }

35416


35417
#else

35418


35419
        {

35420
          RateLimiter_sf(childS);

35421
          sfcnInitializeSizes(childS);

35422
        }

35423


35424
#endif

35425


35426
        sfcnInitializeSampleTimes(childS);

35427


35428
        /* adjust sample time */

35429
        ssSetSampleTime(childS, 0, 0.0);

35430
        ssSetOffsetTime(childS, 0, 0.0);

35431
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

35432


35433
        /* set compiled values of dynamic vector attributes */

35434
        ssSetNumNonsampledZCs(childS, 0);

35435


35436
        /* Update connectivity flags for each port */

35437
        _ssSetInputPortConnected(childS, 0, 1);

35438
        _ssSetInputPortConnected(childS, 1, 1);

35439
        _ssSetInputPortConnected(childS, 2, 1);

35440
        _ssSetInputPortConnected(childS, 3, 1);

35441
        _ssSetInputPortConnected(childS, 4, 1);

35442
        _ssSetOutputPortConnected(childS, 0, 1);

35443
        _ssSetOutputPortConnected(childS, 1, 1);

35444
        _ssSetOutputPortBeingMerged(childS, 0, 0);

35445
        _ssSetOutputPortBeingMerged(childS, 1, 0);

35446


35447
        /* Update the BufferDstPort flags for each input port */

35448
        _ssSetInputPortBufferDstPort(childS, 0, -1);

35449
        _ssSetInputPortBufferDstPort(childS, 1, -1);

35450
        _ssSetInputPortBufferDstPort(childS, 2, -1);

35451
        _ssSetInputPortBufferDstPort(childS, 3, -1);

35452
        _ssSetInputPortBufferDstPort(childS, 4, -1);

35453
      }

35454


35455
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S226>/Generated S-Function1 (SaturationLimiter_sf) */

35456
      {

35457
        SimStruct *childS = ssGetSFunction(rts, 134);

35458


35459
        /* timing info */

35460
        time_T *sfcnPeriod;

35461
        time_T *sfcnOffset;

35462
        int_T *sfcnTsMap;

35463
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

35464
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

35465
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

35466
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

35467
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

35468
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

35469
        (void) memset((void*)sfcnPeriod, 0,

35470
                      sizeof(time_T)*1);

35471
        (void) memset((void*)sfcnOffset, 0,

35472
                      sizeof(time_T)*1);

35473
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

35474
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

35475
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

35476


35477
        /* Set up the mdlInfo pointer */

35478
# ifdef USE_RTMODEL

35479


35480
        {

35481
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

35482
              struct _ssBlkInfo2));

35483
          ss_VALIDATE_MEMORY(rts,blkInfo2);

35484
          ssSetBlkInfo2Ptr(childS, blkInfo2);

35485
        }

35486


35487
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

35488


35489
# else

35490


35491
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

35492


35493
# endif                                /* USE_RTMODEL */

35494


35495
        /* Allocate memory of model methods 2 */

35496
        {

35497
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

35498
            malloc(sizeof(struct _ssSFcnModelMethods2));

35499
          ss_VALIDATE_MEMORY(rts,methods2);

35500
          ssSetModelMethods2(childS, methods2);

35501
        }

35502


35503
        /* Allocate memory of model methods 3 */

35504
        {

35505
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

35506
            malloc(sizeof(struct _ssSFcnModelMethods3));

35507
          ss_VALIDATE_MEMORY(rts,methods3);

35508
          ssSetModelMethods3(childS, methods3);

35509
        }

35510


35511
        /* Allocate memory for states auxilliary information */

35512
        {

35513
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

35514
            (sizeof(struct _ssStatesInfo2));

35515
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

35516
            malloc(sizeof(ssPeriodicStatesInfo));

35517
          ss_VALIDATE_MEMORY(rts,statesInfo2);

35518
          ssSetStatesInfo2(childS, statesInfo2);

35519
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

35520
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

35521
        }

35522


35523
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

35524
          RegNumInputPorts);

35525
        ssSetRegNumInputPortsFcnArg(childS,childS);

35526


35527
        /* inputs */

35528
        {

35529
          struct _ssPortInputs *inputPortInfo =

35530
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

35531
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

35532
          _ssSetNumInputPorts(childS, 3);

35533
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

35534


35535
          /* port 0 */

35536
          {

35537
            real32_T const **sfcnUPtrs = (real32_T const **)

35538
              malloc(1 * sizeof(real32_T *));

35539
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35540
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35541
              ssGetLocalBlockIO(rts))->Switch_c;

35542
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

35543
            _ssSetInputPortNumDimensions(childS, 0, 1);

35544
            ssSetInputPortWidth(childS, 0, 1);

35545
          }

35546


35547
          /* port 1 */

35548
          {

35549
            real32_T const **sfcnUPtrs = (real32_T const **)

35550
              malloc(1 * sizeof(real32_T *));

35551
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35552
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;

35553
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

35554
            _ssSetInputPortNumDimensions(childS, 1, 1);

35555
            ssSetInputPortWidth(childS, 1, 1);

35556
          }

35557


35558
          /* port 2 */

35559
          {

35560
            real32_T const **sfcnUPtrs = (real32_T const **)

35561
              malloc(1 * sizeof(real32_T *));

35562
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35563
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;

35564
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

35565
            _ssSetInputPortNumDimensions(childS, 2, 1);

35566
            ssSetInputPortWidth(childS, 2, 1);

35567
          }

35568
        }

35569


35570
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

35571
          RegNumOutputPorts);

35572
        ssSetRegNumOutputPortsFcnArg(childS,childS);

35573


35574
        /* outputs */

35575
        {

35576
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

35577
            calloc(1, sizeof(struct _ssPortOutputs));

35578
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

35579
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

35580
          _ssSetNumOutputPorts(childS, 1);

35581


35582
          /* port 0 */

35583
          {

35584
            _ssSetOutputPortNumDimensions(childS, 0, 1);

35585
            ssSetOutputPortWidth(childS, 0, 1);

35586
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

35587
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_or));

35588
          }

35589
        }

35590


35591
        /* path info */

35592
        _ssSetModelName(childS, "SaturationLimiter_sf");

35593
        _ssSetPath(childS,

35594
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Saturation Limiter4/Generated S-Function1");

35595
        if (ssGetRTModel(rts) == (NULL)) {

35596
          _ssSetParentSS(childS, rts);

35597
          _ssSetRootSS(childS, ssGetRootSS(rts));

35598
        } else {

35599
          ssSetRTModel(childS,ssGetRTModel(rts));

35600
          _ssSetParentSS(childS, (NULL));

35601
          _ssSetRootSS(childS, childS);

35602
        }

35603


35604
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

35605
        (childS)->regDataType.arg1 = ((void *)(childS));

35606
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

35607
          FcnSetErrorStatus);

35608
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

35609
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

35610
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

35611
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

35612


35613
        /* registration */

35614
#if defined(MATLAB_MEX_FILE)

35615


35616
        {

35617
          int_T i;

35618
          mxArray *plhs[1];

35619
          mxArray *prhs[4];

35620
          double *pr;

35621
          volatile int_T *intS = (int_T *)&childS;

35622
          int_T addrlen = sizeof(SimStruct *);

35623
          int_T m = addrlen/sizeof(int_T) + 1;

35624
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

35625
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

35626
          pr = mxGetPr(prhs[1]);

35627
          for (i = 0; i < m - 1; i++) {

35628
            pr[i] = (double)intS[i];

35629
          }

35630


35631
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

35632
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

35633
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

35634


35635
          /* Reset port dimensions info functions because the S-function

35636
           * and accelerator mex-files explicitly set their dimensions,

35637
           * i.e., they are not dynamically sized. For this case, the

35638
           * mex-file is responsible for the dimensions info memory

35639
           * and Simulink should not free it. This is achieved by

35640
           * setting the following two methods to NULL.

35641
           */

35642
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

35643
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

35644


35645
          /*

35646
           * Setup function pointers and call mdlInitializeSizes via

35647
           * simulink.c

35648
           */

35649
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

35650
          mxDestroyArray(plhs[0]);

35651
          mxDestroyArray(prhs[0]);

35652
          mxDestroyArray(prhs[1]);

35653
          mxDestroyArray(prhs[2]);

35654
          mxDestroyArray(prhs[3]);

35655
        }

35656


35657
#else

35658


35659
        {

35660
          SaturationLimiter_sf(childS);

35661
          sfcnInitializeSizes(childS);

35662
        }

35663


35664
#endif

35665


35666
        sfcnInitializeSampleTimes(childS);

35667


35668
        /* adjust sample time */

35669
        ssSetSampleTime(childS, 0, 0.0);

35670
        ssSetOffsetTime(childS, 0, 0.0);

35671
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

35672


35673
        /* set compiled values of dynamic vector attributes */

35674
        ssSetNumNonsampledZCs(childS, 0);

35675


35676
        /* Update connectivity flags for each port */

35677
        _ssSetInputPortConnected(childS, 0, 1);

35678
        _ssSetInputPortConnected(childS, 1, 1);

35679
        _ssSetInputPortConnected(childS, 2, 1);

35680
        _ssSetOutputPortConnected(childS, 0, 1);

35681
        _ssSetOutputPortBeingMerged(childS, 0, 0);

35682


35683
        /* Update the BufferDstPort flags for each input port */

35684
        _ssSetInputPortBufferDstPort(childS, 0, -1);

35685
        _ssSetInputPortBufferDstPort(childS, 1, -1);

35686
        _ssSetInputPortBufferDstPort(childS, 2, -1);

35687
      }

35688


35689
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S224>/Generated S-Function7 (RateLimiter_sf) */

35690
      {

35691
        SimStruct *childS = ssGetSFunction(rts, 135);

35692


35693
        /* timing info */

35694
        time_T *sfcnPeriod;

35695
        time_T *sfcnOffset;

35696
        int_T *sfcnTsMap;

35697
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

35698
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

35699
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

35700
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

35701
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

35702
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

35703
        (void) memset((void*)sfcnPeriod, 0,

35704
                      sizeof(time_T)*1);

35705
        (void) memset((void*)sfcnOffset, 0,

35706
                      sizeof(time_T)*1);

35707
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

35708
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

35709
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

35710


35711
        /* Set up the mdlInfo pointer */

35712
# ifdef USE_RTMODEL

35713


35714
        {

35715
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

35716
              struct _ssBlkInfo2));

35717
          ss_VALIDATE_MEMORY(rts,blkInfo2);

35718
          ssSetBlkInfo2Ptr(childS, blkInfo2);

35719
        }

35720


35721
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

35722


35723
# else

35724


35725
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

35726


35727
# endif                                /* USE_RTMODEL */

35728


35729
        /* Allocate memory of model methods 2 */

35730
        {

35731
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

35732
            malloc(sizeof(struct _ssSFcnModelMethods2));

35733
          ss_VALIDATE_MEMORY(rts,methods2);

35734
          ssSetModelMethods2(childS, methods2);

35735
        }

35736


35737
        /* Allocate memory of model methods 3 */

35738
        {

35739
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

35740
            malloc(sizeof(struct _ssSFcnModelMethods3));

35741
          ss_VALIDATE_MEMORY(rts,methods3);

35742
          ssSetModelMethods3(childS, methods3);

35743
        }

35744


35745
        /* Allocate memory for states auxilliary information */

35746
        {

35747
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

35748
            (sizeof(struct _ssStatesInfo2));

35749
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

35750
            malloc(sizeof(ssPeriodicStatesInfo));

35751
          ss_VALIDATE_MEMORY(rts,statesInfo2);

35752
          ssSetStatesInfo2(childS, statesInfo2);

35753
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

35754
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

35755
        }

35756


35757
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

35758
          RegNumInputPorts);

35759
        ssSetRegNumInputPortsFcnArg(childS,childS);

35760


35761
        /* inputs */

35762
        {

35763
          struct _ssPortInputs *inputPortInfo =

35764
            (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));

35765
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

35766
          _ssSetNumInputPorts(childS, 5);

35767
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

35768


35769
          /* port 0 */

35770
          {

35771
            int8_T const **sfcnUPtrs = (int8_T const **)

35772
              malloc(1 * sizeof(int8_T *));

35773
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35774
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

35775
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

35776
            _ssSetInputPortNumDimensions(childS, 0, 1);

35777
            ssSetInputPortWidth(childS, 0, 1);

35778
          }

35779


35780
          /* port 1 */

35781
          {

35782
            real32_T const **sfcnUPtrs = (real32_T const **)

35783
              malloc(1 * sizeof(real32_T *));

35784
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35785
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35786
              ssGetLocalBlockIO(rts))->Gain1_o;

35787
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

35788
            _ssSetInputPortNumDimensions(childS, 1, 1);

35789
            ssSetInputPortWidth(childS, 1, 1);

35790
          }

35791


35792
          /* port 2 */

35793
          {

35794
            real32_T const **sfcnUPtrs = (real32_T const **)

35795
              malloc(1 * sizeof(real32_T *));

35796
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35797
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled125;

35798
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

35799
            _ssSetInputPortNumDimensions(childS, 2, 1);

35800
            ssSetInputPortWidth(childS, 2, 1);

35801
          }

35802


35803
          /* port 3 */

35804
          {

35805
            real32_T const **sfcnUPtrs = (real32_T const **)

35806
              malloc(1 * sizeof(real32_T *));

35807
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35808
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35809
              ssGetLocalBlockIO(rts))->dtCAS;

35810
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

35811
            _ssSetInputPortNumDimensions(childS, 3, 1);

35812
            ssSetInputPortWidth(childS, 3, 1);

35813
          }

35814


35815
          /* port 4 */

35816
          {

35817
            real32_T const **sfcnUPtrs = (real32_T const **)

35818
              malloc(1 * sizeof(real32_T *));

35819
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

35820
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

35821
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_or;

35822
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

35823
            _ssSetInputPortNumDimensions(childS, 4, 1);

35824
            ssSetInputPortWidth(childS, 4, 1);

35825
          }

35826
        }

35827


35828
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

35829
          RegNumOutputPorts);

35830
        ssSetRegNumOutputPortsFcnArg(childS,childS);

35831


35832
        /* outputs */

35833
        {

35834
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

35835
            calloc(2, sizeof(struct _ssPortOutputs));

35836
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

35837
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

35838
          _ssSetNumOutputPorts(childS, 2);

35839


35840
          /* port 0 */

35841
          {

35842
            _ssSetOutputPortNumDimensions(childS, 0, 1);

35843
            ssSetOutputPortWidth(childS, 0, 1);

35844
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

35845
              ssGetLocalBlockIO(rts))->drint));

35846
          }

35847


35848
          /* port 1 */

35849
          {

35850
            _ssSetOutputPortNumDimensions(childS, 1, 1);

35851
            ssSetOutputPortWidth(childS, 1, 1);

35852
            _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)

35853
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_i));

35854
          }

35855
        }

35856


35857
        /* path info */

35858
        _ssSetModelName(childS, "RateLimiter_sf");

35859
        _ssSetPath(childS,

35860
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Rate Limiter3/Generated S-Function7");

35861
        if (ssGetRTModel(rts) == (NULL)) {

35862
          _ssSetParentSS(childS, rts);

35863
          _ssSetRootSS(childS, ssGetRootSS(rts));

35864
        } else {

35865
          ssSetRTModel(childS,ssGetRTModel(rts));

35866
          _ssSetParentSS(childS, (NULL));

35867
          _ssSetRootSS(childS, childS);

35868
        }

35869


35870
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

35871


35872
        /* work vectors */

35873
        {

35874
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

35875
            (3 * sizeof(struct _ssDWorkRecord));

35876
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

35877
            calloc(3, sizeof(struct _ssDWorkAuxRecord));

35878
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

35879
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

35880
          ssSetSFcnDWork(childS, dWorkRecord);

35881
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

35882
          _ssSetNumDWork(childS, 3);

35883


35884
          /* DWORK0 */

35885
          ssSetDWorkWidth(childS, 0, 1);

35886
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

35887
          ssSetDWorkComplexSignal(childS, 0, 0);

35888
          ssSetDWorkUsedAsDState(childS, 0, 1);

35889
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 250))[0]);

35890


35891
          /* DWORK1 */

35892
          ssSetDWorkWidth(childS, 1, 1);

35893
          ssSetDWorkDataType(childS, 1,SS_INT8);

35894
          ssSetDWorkComplexSignal(childS, 1, 0);

35895
          ssSetDWorkUsedAsDState(childS, 1, 1);

35896
          _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 479))[0]);

35897


35898
          /* DWORK2 */

35899
          ssSetDWorkWidth(childS, 2, 1);

35900
          ssSetDWorkDataType(childS, 2,SS_INT8);

35901
          ssSetDWorkComplexSignal(childS, 2, 0);

35902
          ssSetDWorkUsedAsDState(childS, 2, 1);

35903
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 480))[0]);

35904
        }

35905


35906
        (childS)->regDataType.arg1 = ((void *)(childS));

35907
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

35908
          FcnSetErrorStatus);

35909
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

35910
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

35911
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

35912
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

35913


35914
        /* registration */

35915
#if defined(MATLAB_MEX_FILE)

35916


35917
        {

35918
          int_T i;

35919
          mxArray *plhs[1];

35920
          mxArray *prhs[4];

35921
          double *pr;

35922
          volatile int_T *intS = (int_T *)&childS;

35923
          int_T addrlen = sizeof(SimStruct *);

35924
          int_T m = addrlen/sizeof(int_T) + 1;

35925
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

35926
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

35927
          pr = mxGetPr(prhs[1]);

35928
          for (i = 0; i < m - 1; i++) {

35929
            pr[i] = (double)intS[i];

35930
          }

35931


35932
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

35933
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

35934
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

35935


35936
          /* Reset port dimensions info functions because the S-function

35937
           * and accelerator mex-files explicitly set their dimensions,

35938
           * i.e., they are not dynamically sized. For this case, the

35939
           * mex-file is responsible for the dimensions info memory

35940
           * and Simulink should not free it. This is achieved by

35941
           * setting the following two methods to NULL.

35942
           */

35943
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

35944
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

35945


35946
          /*

35947
           * Setup function pointers and call mdlInitializeSizes via

35948
           * simulink.c

35949
           */

35950
          mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");

35951
          mxDestroyArray(plhs[0]);

35952
          mxDestroyArray(prhs[0]);

35953
          mxDestroyArray(prhs[1]);

35954
          mxDestroyArray(prhs[2]);

35955
          mxDestroyArray(prhs[3]);

35956
        }

35957


35958
#else

35959


35960
        {

35961
          RateLimiter_sf(childS);

35962
          sfcnInitializeSizes(childS);

35963
        }

35964


35965
#endif

35966


35967
        sfcnInitializeSampleTimes(childS);

35968


35969
        /* adjust sample time */

35970
        ssSetSampleTime(childS, 0, 0.0);

35971
        ssSetOffsetTime(childS, 0, 0.0);

35972
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

35973


35974
        /* set compiled values of dynamic vector attributes */

35975
        ssSetNumNonsampledZCs(childS, 0);

35976


35977
        /* Update connectivity flags for each port */

35978
        _ssSetInputPortConnected(childS, 0, 1);

35979
        _ssSetInputPortConnected(childS, 1, 1);

35980
        _ssSetInputPortConnected(childS, 2, 1);

35981
        _ssSetInputPortConnected(childS, 3, 1);

35982
        _ssSetInputPortConnected(childS, 4, 1);

35983
        _ssSetOutputPortConnected(childS, 0, 1);

35984
        _ssSetOutputPortConnected(childS, 1, 1);

35985
        _ssSetOutputPortBeingMerged(childS, 0, 0);

35986
        _ssSetOutputPortBeingMerged(childS, 1, 0);

35987


35988
        /* Update the BufferDstPort flags for each input port */

35989
        _ssSetInputPortBufferDstPort(childS, 0, -1);

35990
        _ssSetInputPortBufferDstPort(childS, 1, -1);

35991
        _ssSetInputPortBufferDstPort(childS, 2, -1);

35992
        _ssSetInputPortBufferDstPort(childS, 3, -1);

35993
        _ssSetInputPortBufferDstPort(childS, 4, -1);

35994
      }

35995


35996
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S252>/Generated S-Function8 (WashoutFilter_sf) */

35997
      {

35998
        SimStruct *childS = ssGetSFunction(rts, 136);

35999


36000
        /* timing info */

36001
        time_T *sfcnPeriod;

36002
        time_T *sfcnOffset;

36003
        int_T *sfcnTsMap;

36004
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

36005
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

36006
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

36007
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

36008
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

36009
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

36010
        (void) memset((void*)sfcnPeriod, 0,

36011
                      sizeof(time_T)*1);

36012
        (void) memset((void*)sfcnOffset, 0,

36013
                      sizeof(time_T)*1);

36014
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

36015
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

36016
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

36017


36018
        /* Set up the mdlInfo pointer */

36019
# ifdef USE_RTMODEL

36020


36021
        {

36022
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

36023
              struct _ssBlkInfo2));

36024
          ss_VALIDATE_MEMORY(rts,blkInfo2);

36025
          ssSetBlkInfo2Ptr(childS, blkInfo2);

36026
        }

36027


36028
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

36029


36030
# else

36031


36032
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

36033


36034
# endif                                /* USE_RTMODEL */

36035


36036
        /* Allocate memory of model methods 2 */

36037
        {

36038
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

36039
            malloc(sizeof(struct _ssSFcnModelMethods2));

36040
          ss_VALIDATE_MEMORY(rts,methods2);

36041
          ssSetModelMethods2(childS, methods2);

36042
        }

36043


36044
        /* Allocate memory of model methods 3 */

36045
        {

36046
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

36047
            malloc(sizeof(struct _ssSFcnModelMethods3));

36048
          ss_VALIDATE_MEMORY(rts,methods3);

36049
          ssSetModelMethods3(childS, methods3);

36050
        }

36051


36052
        /* Allocate memory for states auxilliary information */

36053
        {

36054
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

36055
            (sizeof(struct _ssStatesInfo2));

36056
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

36057
            malloc(sizeof(ssPeriodicStatesInfo));

36058
          ss_VALIDATE_MEMORY(rts,statesInfo2);

36059
          ssSetStatesInfo2(childS, statesInfo2);

36060
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

36061
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

36062
        }

36063


36064
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

36065
          RegNumInputPorts);

36066
        ssSetRegNumInputPortsFcnArg(childS,childS);

36067


36068
        /* inputs */

36069
        {

36070
          struct _ssPortInputs *inputPortInfo =

36071
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

36072
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

36073
          _ssSetNumInputPorts(childS, 6);

36074
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

36075


36076
          /* port 0 */

36077
          {

36078
            real32_T const **sfcnUPtrs = (real32_T const **)

36079
              malloc(1 * sizeof(real32_T *));

36080
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36081
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36082
              ssGetLocalBlockIO(rts))->dtCAS;

36083
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

36084
            _ssSetInputPortNumDimensions(childS, 0, 1);

36085
            ssSetInputPortWidth(childS, 0, 1);

36086
          }

36087


36088
          /* port 1 */

36089
          {

36090
            int8_T const **sfcnUPtrs = (int8_T const **)

36091
              malloc(1 * sizeof(int8_T *));

36092
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36093
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

36094
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

36095
            _ssSetInputPortNumDimensions(childS, 1, 1);

36096
            ssSetInputPortWidth(childS, 1, 1);

36097
          }

36098


36099
          /* port 2 */

36100
          {

36101
            real32_T const **sfcnUPtrs = (real32_T const **)

36102
              malloc(1 * sizeof(real32_T *));

36103
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36104
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

36105
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

36106
            _ssSetInputPortNumDimensions(childS, 2, 1);

36107
            ssSetInputPortWidth(childS, 2, 1);

36108
          }

36109


36110
          /* port 3 */

36111
          {

36112
            real32_T const **sfcnUPtrs = (real32_T const **)

36113
              malloc(1 * sizeof(real32_T *));

36114
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36115
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36116
              ssGetLocalBlockIO(rts))->q_k;

36117
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

36118
            _ssSetInputPortNumDimensions(childS, 3, 1);

36119
            ssSetInputPortWidth(childS, 3, 1);

36120
          }

36121


36122
          /* port 4 */

36123
          {

36124
            real32_T const **sfcnUPtrs = (real32_T const **)

36125
              malloc(1 * sizeof(real32_T *));

36126
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36127
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36128
              ssGetLocalBlockIO(rts))->q_k;

36129
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

36130
            _ssSetInputPortNumDimensions(childS, 4, 1);

36131
            ssSetInputPortWidth(childS, 4, 1);

36132
          }

36133


36134
          /* port 5 */

36135
          {

36136
            real32_T const **sfcnUPtrs = (real32_T const **)

36137
              malloc(1 * sizeof(real32_T *));

36138
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36139
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36140
              ssGetLocalBlockIO(rts))->q_k;

36141
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

36142
            _ssSetInputPortNumDimensions(childS, 5, 1);

36143
            ssSetInputPortWidth(childS, 5, 1);

36144
          }

36145
        }

36146


36147
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

36148
          RegNumOutputPorts);

36149
        ssSetRegNumOutputPortsFcnArg(childS,childS);

36150


36151
        /* outputs */

36152
        {

36153
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

36154
            calloc(1, sizeof(struct _ssPortOutputs));

36155
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

36156
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

36157
          _ssSetNumOutputPorts(childS, 1);

36158


36159
          /* port 0 */

36160
          {

36161
            _ssSetOutputPortNumDimensions(childS, 0, 1);

36162
            ssSetOutputPortWidth(childS, 0, 1);

36163
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

36164
              ssGetLocalBlockIO(rts))->GeneratedSFunction8_p));

36165
          }

36166
        }

36167


36168
        /* path info */

36169
        _ssSetModelName(childS, "WashoutFilter_sf");

36170
        _ssSetPath(childS,

36171
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ high pass filter/Generated S-Function8");

36172
        if (ssGetRTModel(rts) == (NULL)) {

36173
          _ssSetParentSS(childS, rts);

36174
          _ssSetRootSS(childS, ssGetRootSS(rts));

36175
        } else {

36176
          ssSetRTModel(childS,ssGetRTModel(rts));

36177
          _ssSetParentSS(childS, (NULL));

36178
          _ssSetRootSS(childS, childS);

36179
        }

36180


36181
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

36182


36183
        /* work vectors */

36184
        {

36185
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

36186
            (4 * sizeof(struct _ssDWorkRecord));

36187
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

36188
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

36189
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

36190
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

36191
          ssSetSFcnDWork(childS, dWorkRecord);

36192
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

36193
          _ssSetNumDWork(childS, 4);

36194


36195
          /* DWORK0 */

36196
          ssSetDWorkWidth(childS, 0, 1);

36197
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

36198
          ssSetDWorkComplexSignal(childS, 0, 0);

36199
          ssSetDWorkUsedAsDState(childS, 0, 1);

36200
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 251))[0]);

36201


36202
          /* DWORK1 */

36203
          ssSetDWorkWidth(childS, 1, 1);

36204
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

36205
          ssSetDWorkComplexSignal(childS, 1, 0);

36206
          ssSetDWorkUsedAsDState(childS, 1, 1);

36207
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 252))[0]);

36208


36209
          /* DWORK2 */

36210
          ssSetDWorkWidth(childS, 2, 1);

36211
          ssSetDWorkDataType(childS, 2,SS_INT8);

36212
          ssSetDWorkComplexSignal(childS, 2, 0);

36213
          ssSetDWorkUsedAsDState(childS, 2, 1);

36214
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 481))[0]);

36215


36216
          /* DWORK3 */

36217
          ssSetDWorkWidth(childS, 3, 1);

36218
          ssSetDWorkDataType(childS, 3,SS_INT8);

36219
          ssSetDWorkComplexSignal(childS, 3, 0);

36220
          ssSetDWorkUsedAsDState(childS, 3, 1);

36221
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 482))[0]);

36222
        }

36223


36224
        (childS)->regDataType.arg1 = ((void *)(childS));

36225
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

36226
          FcnSetErrorStatus);

36227
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

36228
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

36229
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

36230
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

36231


36232
        /* registration */

36233
#if defined(MATLAB_MEX_FILE)

36234


36235
        {

36236
          int_T i;

36237
          mxArray *plhs[1];

36238
          mxArray *prhs[4];

36239
          double *pr;

36240
          volatile int_T *intS = (int_T *)&childS;

36241
          int_T addrlen = sizeof(SimStruct *);

36242
          int_T m = addrlen/sizeof(int_T) + 1;

36243
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

36244
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

36245
          pr = mxGetPr(prhs[1]);

36246
          for (i = 0; i < m - 1; i++) {

36247
            pr[i] = (double)intS[i];

36248
          }

36249


36250
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

36251
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

36252
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

36253


36254
          /* Reset port dimensions info functions because the S-function

36255
           * and accelerator mex-files explicitly set their dimensions,

36256
           * i.e., they are not dynamically sized. For this case, the

36257
           * mex-file is responsible for the dimensions info memory

36258
           * and Simulink should not free it. This is achieved by

36259
           * setting the following two methods to NULL.

36260
           */

36261
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

36262
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

36263


36264
          /*

36265
           * Setup function pointers and call mdlInitializeSizes via

36266
           * simulink.c

36267
           */

36268
          mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");

36269
          mxDestroyArray(plhs[0]);

36270
          mxDestroyArray(prhs[0]);

36271
          mxDestroyArray(prhs[1]);

36272
          mxDestroyArray(prhs[2]);

36273
          mxDestroyArray(prhs[3]);

36274
        }

36275


36276
#else

36277


36278
        {

36279
          WashoutFilter_sf(childS);

36280
          sfcnInitializeSizes(childS);

36281
        }

36282


36283
#endif

36284


36285
        sfcnInitializeSampleTimes(childS);

36286


36287
        /* adjust sample time */

36288
        ssSetSampleTime(childS, 0, 0.0);

36289
        ssSetOffsetTime(childS, 0, 0.0);

36290
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

36291


36292
        /* set compiled values of dynamic vector attributes */

36293
        ssSetNumNonsampledZCs(childS, 0);

36294


36295
        /* Update connectivity flags for each port */

36296
        _ssSetInputPortConnected(childS, 0, 1);

36297
        _ssSetInputPortConnected(childS, 1, 1);

36298
        _ssSetInputPortConnected(childS, 2, 1);

36299
        _ssSetInputPortConnected(childS, 3, 1);

36300
        _ssSetInputPortConnected(childS, 4, 1);

36301
        _ssSetInputPortConnected(childS, 5, 1);

36302
        _ssSetOutputPortConnected(childS, 0, 1);

36303
        _ssSetOutputPortBeingMerged(childS, 0, 0);

36304


36305
        /* Update the BufferDstPort flags for each input port */

36306
        _ssSetInputPortBufferDstPort(childS, 0, -1);

36307
        _ssSetInputPortBufferDstPort(childS, 1, -1);

36308
        _ssSetInputPortBufferDstPort(childS, 2, -1);

36309
        _ssSetInputPortBufferDstPort(childS, 3, -1);

36310
        _ssSetInputPortBufferDstPort(childS, 4, -1);

36311
        _ssSetInputPortBufferDstPort(childS, 5, -1);

36312
      }

36313


36314
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S253>/Generated S-Function4 (LagFilter_sf) */

36315
      {

36316
        SimStruct *childS = ssGetSFunction(rts, 137);

36317


36318
        /* timing info */

36319
        time_T *sfcnPeriod;

36320
        time_T *sfcnOffset;

36321
        int_T *sfcnTsMap;

36322
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

36323
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

36324
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

36325
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

36326
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

36327
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

36328
        (void) memset((void*)sfcnPeriod, 0,

36329
                      sizeof(time_T)*1);

36330
        (void) memset((void*)sfcnOffset, 0,

36331
                      sizeof(time_T)*1);

36332
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

36333
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

36334
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

36335


36336
        /* Set up the mdlInfo pointer */

36337
# ifdef USE_RTMODEL

36338


36339
        {

36340
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

36341
              struct _ssBlkInfo2));

36342
          ss_VALIDATE_MEMORY(rts,blkInfo2);

36343
          ssSetBlkInfo2Ptr(childS, blkInfo2);

36344
        }

36345


36346
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

36347


36348
# else

36349


36350
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

36351


36352
# endif                                /* USE_RTMODEL */

36353


36354
        /* Allocate memory of model methods 2 */

36355
        {

36356
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

36357
            malloc(sizeof(struct _ssSFcnModelMethods2));

36358
          ss_VALIDATE_MEMORY(rts,methods2);

36359
          ssSetModelMethods2(childS, methods2);

36360
        }

36361


36362
        /* Allocate memory of model methods 3 */

36363
        {

36364
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

36365
            malloc(sizeof(struct _ssSFcnModelMethods3));

36366
          ss_VALIDATE_MEMORY(rts,methods3);

36367
          ssSetModelMethods3(childS, methods3);

36368
        }

36369


36370
        /* Allocate memory for states auxilliary information */

36371
        {

36372
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

36373
            (sizeof(struct _ssStatesInfo2));

36374
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

36375
            malloc(sizeof(ssPeriodicStatesInfo));

36376
          ss_VALIDATE_MEMORY(rts,statesInfo2);

36377
          ssSetStatesInfo2(childS, statesInfo2);

36378
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

36379
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

36380
        }

36381


36382
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

36383
          RegNumInputPorts);

36384
        ssSetRegNumInputPortsFcnArg(childS,childS);

36385


36386
        /* inputs */

36387
        {

36388
          struct _ssPortInputs *inputPortInfo =

36389
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

36390
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

36391
          _ssSetNumInputPorts(childS, 6);

36392
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

36393


36394
          /* port 0 */

36395
          {

36396
            real32_T const **sfcnUPtrs = (real32_T const **)

36397
              malloc(1 * sizeof(real32_T *));

36398
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36399
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36400
              ssGetLocalBlockIO(rts))->dtCAS;

36401
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

36402
            _ssSetInputPortNumDimensions(childS, 0, 1);

36403
            ssSetInputPortWidth(childS, 0, 1);

36404
          }

36405


36406
          /* port 1 */

36407
          {

36408
            int8_T const **sfcnUPtrs = (int8_T const **)

36409
              malloc(1 * sizeof(int8_T *));

36410
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36411
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

36412
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

36413
            _ssSetInputPortNumDimensions(childS, 1, 1);

36414
            ssSetInputPortWidth(childS, 1, 1);

36415
          }

36416


36417
          /* port 2 */

36418
          {

36419
            real32_T const **sfcnUPtrs = (real32_T const **)

36420
              malloc(1 * sizeof(real32_T *));

36421
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36422
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;

36423
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

36424
            _ssSetInputPortNumDimensions(childS, 2, 1);

36425
            ssSetInputPortWidth(childS, 2, 1);

36426
          }

36427


36428
          /* port 3 */

36429
          {

36430
            real32_T const **sfcnUPtrs = (real32_T const **)

36431
              malloc(1 * sizeof(real32_T *));

36432
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36433
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36434
              ssGetLocalBlockIO(rts))->Sum1_e;

36435
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

36436
            _ssSetInputPortNumDimensions(childS, 3, 1);

36437
            ssSetInputPortWidth(childS, 3, 1);

36438
          }

36439


36440
          /* port 4 */

36441
          {

36442
            real32_T const **sfcnUPtrs = (real32_T const **)

36443
              malloc(1 * sizeof(real32_T *));

36444
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36445
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36446
              ssGetLocalBlockIO(rts))->Sum1_e;

36447
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

36448
            _ssSetInputPortNumDimensions(childS, 4, 1);

36449
            ssSetInputPortWidth(childS, 4, 1);

36450
          }

36451


36452
          /* port 5 */

36453
          {

36454
            real32_T const **sfcnUPtrs = (real32_T const **)

36455
              malloc(1 * sizeof(real32_T *));

36456
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36457
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36458
              ssGetLocalBlockIO(rts))->Sum1_e;

36459
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

36460
            _ssSetInputPortNumDimensions(childS, 5, 1);

36461
            ssSetInputPortWidth(childS, 5, 1);

36462
          }

36463
        }

36464


36465
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

36466
          RegNumOutputPorts);

36467
        ssSetRegNumOutputPortsFcnArg(childS,childS);

36468


36469
        /* outputs */

36470
        {

36471
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

36472
            calloc(1, sizeof(struct _ssPortOutputs));

36473
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

36474
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

36475
          _ssSetNumOutputPorts(childS, 1);

36476


36477
          /* port 0 */

36478
          {

36479
            _ssSetOutputPortNumDimensions(childS, 0, 1);

36480
            ssSetOutputPortWidth(childS, 0, 1);

36481
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

36482
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_e));

36483
          }

36484
        }

36485


36486
        /* path info */

36487
        _ssSetModelName(childS, "LagFilter_sf");

36488
        _ssSetPath(childS,

36489
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ lag filter/Generated S-Function4");

36490
        if (ssGetRTModel(rts) == (NULL)) {

36491
          _ssSetParentSS(childS, rts);

36492
          _ssSetRootSS(childS, ssGetRootSS(rts));

36493
        } else {

36494
          ssSetRTModel(childS,ssGetRTModel(rts));

36495
          _ssSetParentSS(childS, (NULL));

36496
          _ssSetRootSS(childS, childS);

36497
        }

36498


36499
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

36500


36501
        /* work vectors */

36502
        {

36503
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

36504
            (4 * sizeof(struct _ssDWorkRecord));

36505
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

36506
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

36507
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

36508
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

36509
          ssSetSFcnDWork(childS, dWorkRecord);

36510
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

36511
          _ssSetNumDWork(childS, 4);

36512


36513
          /* DWORK0 */

36514
          ssSetDWorkWidth(childS, 0, 1);

36515
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

36516
          ssSetDWorkComplexSignal(childS, 0, 0);

36517
          ssSetDWorkUsedAsDState(childS, 0, 1);

36518
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 253))[0]);

36519


36520
          /* DWORK1 */

36521
          ssSetDWorkWidth(childS, 1, 1);

36522
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

36523
          ssSetDWorkComplexSignal(childS, 1, 0);

36524
          ssSetDWorkUsedAsDState(childS, 1, 1);

36525
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 254))[0]);

36526


36527
          /* DWORK2 */

36528
          ssSetDWorkWidth(childS, 2, 1);

36529
          ssSetDWorkDataType(childS, 2,SS_INT8);

36530
          ssSetDWorkComplexSignal(childS, 2, 0);

36531
          ssSetDWorkUsedAsDState(childS, 2, 1);

36532
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 483))[0]);

36533


36534
          /* DWORK3 */

36535
          ssSetDWorkWidth(childS, 3, 1);

36536
          ssSetDWorkDataType(childS, 3,SS_INT8);

36537
          ssSetDWorkComplexSignal(childS, 3, 0);

36538
          ssSetDWorkUsedAsDState(childS, 3, 1);

36539
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 484))[0]);

36540
        }

36541


36542
        (childS)->regDataType.arg1 = ((void *)(childS));

36543
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

36544
          FcnSetErrorStatus);

36545
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

36546
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

36547
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

36548
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

36549


36550
        /* registration */

36551
#if defined(MATLAB_MEX_FILE)

36552


36553
        {

36554
          int_T i;

36555
          mxArray *plhs[1];

36556
          mxArray *prhs[4];

36557
          double *pr;

36558
          volatile int_T *intS = (int_T *)&childS;

36559
          int_T addrlen = sizeof(SimStruct *);

36560
          int_T m = addrlen/sizeof(int_T) + 1;

36561
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

36562
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

36563
          pr = mxGetPr(prhs[1]);

36564
          for (i = 0; i < m - 1; i++) {

36565
            pr[i] = (double)intS[i];

36566
          }

36567


36568
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

36569
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

36570
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

36571


36572
          /* Reset port dimensions info functions because the S-function

36573
           * and accelerator mex-files explicitly set their dimensions,

36574
           * i.e., they are not dynamically sized. For this case, the

36575
           * mex-file is responsible for the dimensions info memory

36576
           * and Simulink should not free it. This is achieved by

36577
           * setting the following two methods to NULL.

36578
           */

36579
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

36580
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

36581


36582
          /*

36583
           * Setup function pointers and call mdlInitializeSizes via

36584
           * simulink.c

36585
           */

36586
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

36587
          mxDestroyArray(plhs[0]);

36588
          mxDestroyArray(prhs[0]);

36589
          mxDestroyArray(prhs[1]);

36590
          mxDestroyArray(prhs[2]);

36591
          mxDestroyArray(prhs[3]);

36592
        }

36593


36594
#else

36595


36596
        {

36597
          LagFilter_sf(childS);

36598
          sfcnInitializeSizes(childS);

36599
        }

36600


36601
#endif

36602


36603
        sfcnInitializeSampleTimes(childS);

36604


36605
        /* adjust sample time */

36606
        ssSetSampleTime(childS, 0, 0.0);

36607
        ssSetOffsetTime(childS, 0, 0.0);

36608
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

36609


36610
        /* set compiled values of dynamic vector attributes */

36611
        ssSetNumNonsampledZCs(childS, 0);

36612


36613
        /* Update connectivity flags for each port */

36614
        _ssSetInputPortConnected(childS, 0, 1);

36615
        _ssSetInputPortConnected(childS, 1, 1);

36616
        _ssSetInputPortConnected(childS, 2, 1);

36617
        _ssSetInputPortConnected(childS, 3, 1);

36618
        _ssSetInputPortConnected(childS, 4, 1);

36619
        _ssSetInputPortConnected(childS, 5, 1);

36620
        _ssSetOutputPortConnected(childS, 0, 1);

36621
        _ssSetOutputPortBeingMerged(childS, 0, 0);

36622


36623
        /* Update the BufferDstPort flags for each input port */

36624
        _ssSetInputPortBufferDstPort(childS, 0, -1);

36625
        _ssSetInputPortBufferDstPort(childS, 1, -1);

36626
        _ssSetInputPortBufferDstPort(childS, 2, -1);

36627
        _ssSetInputPortBufferDstPort(childS, 3, -1);

36628
        _ssSetInputPortBufferDstPort(childS, 4, -1);

36629
        _ssSetInputPortBufferDstPort(childS, 5, -1);

36630
      }

36631


36632
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S254>/Generated S-Function4 (LagFilter_sf) */

36633
      {

36634
        SimStruct *childS = ssGetSFunction(rts, 138);

36635


36636
        /* timing info */

36637
        time_T *sfcnPeriod;

36638
        time_T *sfcnOffset;

36639
        int_T *sfcnTsMap;

36640
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

36641
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

36642
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

36643
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

36644
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

36645
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

36646
        (void) memset((void*)sfcnPeriod, 0,

36647
                      sizeof(time_T)*1);

36648
        (void) memset((void*)sfcnOffset, 0,

36649
                      sizeof(time_T)*1);

36650
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

36651
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

36652
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

36653


36654
        /* Set up the mdlInfo pointer */

36655
# ifdef USE_RTMODEL

36656


36657
        {

36658
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

36659
              struct _ssBlkInfo2));

36660
          ss_VALIDATE_MEMORY(rts,blkInfo2);

36661
          ssSetBlkInfo2Ptr(childS, blkInfo2);

36662
        }

36663


36664
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

36665


36666
# else

36667


36668
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

36669


36670
# endif                                /* USE_RTMODEL */

36671


36672
        /* Allocate memory of model methods 2 */

36673
        {

36674
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

36675
            malloc(sizeof(struct _ssSFcnModelMethods2));

36676
          ss_VALIDATE_MEMORY(rts,methods2);

36677
          ssSetModelMethods2(childS, methods2);

36678
        }

36679


36680
        /* Allocate memory of model methods 3 */

36681
        {

36682
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

36683
            malloc(sizeof(struct _ssSFcnModelMethods3));

36684
          ss_VALIDATE_MEMORY(rts,methods3);

36685
          ssSetModelMethods3(childS, methods3);

36686
        }

36687


36688
        /* Allocate memory for states auxilliary information */

36689
        {

36690
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

36691
            (sizeof(struct _ssStatesInfo2));

36692
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

36693
            malloc(sizeof(ssPeriodicStatesInfo));

36694
          ss_VALIDATE_MEMORY(rts,statesInfo2);

36695
          ssSetStatesInfo2(childS, statesInfo2);

36696
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

36697
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

36698
        }

36699


36700
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

36701
          RegNumInputPorts);

36702
        ssSetRegNumInputPortsFcnArg(childS,childS);

36703


36704
        /* inputs */

36705
        {

36706
          struct _ssPortInputs *inputPortInfo =

36707
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

36708
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

36709
          _ssSetNumInputPorts(childS, 6);

36710
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

36711


36712
          /* port 0 */

36713
          {

36714
            real32_T const **sfcnUPtrs = (real32_T const **)

36715
              malloc(1 * sizeof(real32_T *));

36716
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36717
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36718
              ssGetLocalBlockIO(rts))->dtCAS;

36719
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

36720
            _ssSetInputPortNumDimensions(childS, 0, 1);

36721
            ssSetInputPortWidth(childS, 0, 1);

36722
          }

36723


36724
          /* port 1 */

36725
          {

36726
            int8_T const **sfcnUPtrs = (int8_T const **)

36727
              malloc(1 * sizeof(int8_T *));

36728
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36729
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

36730
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

36731
            _ssSetInputPortNumDimensions(childS, 1, 1);

36732
            ssSetInputPortWidth(childS, 1, 1);

36733
          }

36734


36735
          /* port 2 */

36736
          {

36737
            real32_T const **sfcnUPtrs = (real32_T const **)

36738
              malloc(1 * sizeof(real32_T *));

36739
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36740
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;

36741
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

36742
            _ssSetInputPortNumDimensions(childS, 2, 1);

36743
            ssSetInputPortWidth(childS, 2, 1);

36744
          }

36745


36746
          /* port 3 */

36747
          {

36748
            real32_T const **sfcnUPtrs = (real32_T const **)

36749
              malloc(1 * sizeof(real32_T *));

36750
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36751
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36752
              ssGetLocalBlockIO(rts))->q_k;

36753
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

36754
            _ssSetInputPortNumDimensions(childS, 3, 1);

36755
            ssSetInputPortWidth(childS, 3, 1);

36756
          }

36757


36758
          /* port 4 */

36759
          {

36760
            real32_T const **sfcnUPtrs = (real32_T const **)

36761
              malloc(1 * sizeof(real32_T *));

36762
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36763
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36764
              ssGetLocalBlockIO(rts))->q_k;

36765
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

36766
            _ssSetInputPortNumDimensions(childS, 4, 1);

36767
            ssSetInputPortWidth(childS, 4, 1);

36768
          }

36769


36770
          /* port 5 */

36771
          {

36772
            real32_T const **sfcnUPtrs = (real32_T const **)

36773
              malloc(1 * sizeof(real32_T *));

36774
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

36775
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

36776
              ssGetLocalBlockIO(rts))->q_k;

36777
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

36778
            _ssSetInputPortNumDimensions(childS, 5, 1);

36779
            ssSetInputPortWidth(childS, 5, 1);

36780
          }

36781
        }

36782


36783
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

36784
          RegNumOutputPorts);

36785
        ssSetRegNumOutputPortsFcnArg(childS,childS);

36786


36787
        /* outputs */

36788
        {

36789
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

36790
            calloc(1, sizeof(struct _ssPortOutputs));

36791
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

36792
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

36793
          _ssSetNumOutputPorts(childS, 1);

36794


36795
          /* port 0 */

36796
          {

36797
            _ssSetOutputPortNumDimensions(childS, 0, 1);

36798
            ssSetOutputPortWidth(childS, 0, 1);

36799
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

36800
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_ms));

36801
          }

36802
        }

36803


36804
        /* path info */

36805
        _ssSetModelName(childS, "LagFilter_sf");

36806
        _ssSetPath(childS,

36807
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ lag filter1/Generated S-Function4");

36808
        if (ssGetRTModel(rts) == (NULL)) {

36809
          _ssSetParentSS(childS, rts);

36810
          _ssSetRootSS(childS, ssGetRootSS(rts));

36811
        } else {

36812
          ssSetRTModel(childS,ssGetRTModel(rts));

36813
          _ssSetParentSS(childS, (NULL));

36814
          _ssSetRootSS(childS, childS);

36815
        }

36816


36817
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

36818


36819
        /* work vectors */

36820
        {

36821
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

36822
            (4 * sizeof(struct _ssDWorkRecord));

36823
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

36824
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

36825
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

36826
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

36827
          ssSetSFcnDWork(childS, dWorkRecord);

36828
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

36829
          _ssSetNumDWork(childS, 4);

36830


36831
          /* DWORK0 */

36832
          ssSetDWorkWidth(childS, 0, 1);

36833
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

36834
          ssSetDWorkComplexSignal(childS, 0, 0);

36835
          ssSetDWorkUsedAsDState(childS, 0, 1);

36836
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 255))[0]);

36837


36838
          /* DWORK1 */

36839
          ssSetDWorkWidth(childS, 1, 1);

36840
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

36841
          ssSetDWorkComplexSignal(childS, 1, 0);

36842
          ssSetDWorkUsedAsDState(childS, 1, 1);

36843
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 256))[0]);

36844


36845
          /* DWORK2 */

36846
          ssSetDWorkWidth(childS, 2, 1);

36847
          ssSetDWorkDataType(childS, 2,SS_INT8);

36848
          ssSetDWorkComplexSignal(childS, 2, 0);

36849
          ssSetDWorkUsedAsDState(childS, 2, 1);

36850
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 485))[0]);

36851


36852
          /* DWORK3 */

36853
          ssSetDWorkWidth(childS, 3, 1);

36854
          ssSetDWorkDataType(childS, 3,SS_INT8);

36855
          ssSetDWorkComplexSignal(childS, 3, 0);

36856
          ssSetDWorkUsedAsDState(childS, 3, 1);

36857
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 486))[0]);

36858
        }

36859


36860
        (childS)->regDataType.arg1 = ((void *)(childS));

36861
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

36862
          FcnSetErrorStatus);

36863
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

36864
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

36865
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

36866
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

36867


36868
        /* registration */

36869
#if defined(MATLAB_MEX_FILE)

36870


36871
        {

36872
          int_T i;

36873
          mxArray *plhs[1];

36874
          mxArray *prhs[4];

36875
          double *pr;

36876
          volatile int_T *intS = (int_T *)&childS;

36877
          int_T addrlen = sizeof(SimStruct *);

36878
          int_T m = addrlen/sizeof(int_T) + 1;

36879
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

36880
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

36881
          pr = mxGetPr(prhs[1]);

36882
          for (i = 0; i < m - 1; i++) {

36883
            pr[i] = (double)intS[i];

36884
          }

36885


36886
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

36887
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

36888
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

36889


36890
          /* Reset port dimensions info functions because the S-function

36891
           * and accelerator mex-files explicitly set their dimensions,

36892
           * i.e., they are not dynamically sized. For this case, the

36893
           * mex-file is responsible for the dimensions info memory

36894
           * and Simulink should not free it. This is achieved by

36895
           * setting the following two methods to NULL.

36896
           */

36897
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

36898
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

36899


36900
          /*

36901
           * Setup function pointers and call mdlInitializeSizes via

36902
           * simulink.c

36903
           */

36904
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

36905
          mxDestroyArray(plhs[0]);

36906
          mxDestroyArray(prhs[0]);

36907
          mxDestroyArray(prhs[1]);

36908
          mxDestroyArray(prhs[2]);

36909
          mxDestroyArray(prhs[3]);

36910
        }

36911


36912
#else

36913


36914
        {

36915
          LagFilter_sf(childS);

36916
          sfcnInitializeSizes(childS);

36917
        }

36918


36919
#endif

36920


36921
        sfcnInitializeSampleTimes(childS);

36922


36923
        /* adjust sample time */

36924
        ssSetSampleTime(childS, 0, 0.0);

36925
        ssSetOffsetTime(childS, 0, 0.0);

36926
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

36927


36928
        /* set compiled values of dynamic vector attributes */

36929
        ssSetNumNonsampledZCs(childS, 0);

36930


36931
        /* Update connectivity flags for each port */

36932
        _ssSetInputPortConnected(childS, 0, 1);

36933
        _ssSetInputPortConnected(childS, 1, 1);

36934
        _ssSetInputPortConnected(childS, 2, 1);

36935
        _ssSetInputPortConnected(childS, 3, 1);

36936
        _ssSetInputPortConnected(childS, 4, 1);

36937
        _ssSetInputPortConnected(childS, 5, 1);

36938
        _ssSetOutputPortConnected(childS, 0, 1);

36939
        _ssSetOutputPortBeingMerged(childS, 0, 0);

36940


36941
        /* Update the BufferDstPort flags for each input port */

36942
        _ssSetInputPortBufferDstPort(childS, 0, -1);

36943
        _ssSetInputPortBufferDstPort(childS, 1, -1);

36944
        _ssSetInputPortBufferDstPort(childS, 2, -1);

36945
        _ssSetInputPortBufferDstPort(childS, 3, -1);

36946
        _ssSetInputPortBufferDstPort(childS, 4, -1);

36947
        _ssSetInputPortBufferDstPort(childS, 5, -1);

36948
      }

36949


36950
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S259>/Generated S-Function (Gain_sf) */

36951
      {

36952
        SimStruct *childS = ssGetSFunction(rts, 139);

36953


36954
        /* timing info */

36955
        time_T *sfcnPeriod;

36956
        time_T *sfcnOffset;

36957
        int_T *sfcnTsMap;

36958
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

36959
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

36960
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

36961
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

36962
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

36963
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

36964
        (void) memset((void*)sfcnPeriod, 0,

36965
                      sizeof(time_T)*1);

36966
        (void) memset((void*)sfcnOffset, 0,

36967
                      sizeof(time_T)*1);

36968
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

36969
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

36970
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

36971


36972
        /* Set up the mdlInfo pointer */

36973
# ifdef USE_RTMODEL

36974


36975
        {

36976
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

36977
              struct _ssBlkInfo2));

36978
          ss_VALIDATE_MEMORY(rts,blkInfo2);

36979
          ssSetBlkInfo2Ptr(childS, blkInfo2);

36980
        }

36981


36982
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

36983


36984
# else

36985


36986
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

36987


36988
# endif                                /* USE_RTMODEL */

36989


36990
        /* Allocate memory of model methods 2 */

36991
        {

36992
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

36993
            malloc(sizeof(struct _ssSFcnModelMethods2));

36994
          ss_VALIDATE_MEMORY(rts,methods2);

36995
          ssSetModelMethods2(childS, methods2);

36996
        }

36997


36998
        /* Allocate memory of model methods 3 */

36999
        {

37000
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

37001
            malloc(sizeof(struct _ssSFcnModelMethods3));

37002
          ss_VALIDATE_MEMORY(rts,methods3);

37003
          ssSetModelMethods3(childS, methods3);

37004
        }

37005


37006
        /* Allocate memory for states auxilliary information */

37007
        {

37008
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

37009
            (sizeof(struct _ssStatesInfo2));

37010
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

37011
            malloc(sizeof(ssPeriodicStatesInfo));

37012
          ss_VALIDATE_MEMORY(rts,statesInfo2);

37013
          ssSetStatesInfo2(childS, statesInfo2);

37014
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

37015
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

37016
        }

37017


37018
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

37019
          RegNumInputPorts);

37020
        ssSetRegNumInputPortsFcnArg(childS,childS);

37021


37022
        /* inputs */

37023
        {

37024
          struct _ssPortInputs *inputPortInfo =

37025
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

37026
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

37027
          _ssSetNumInputPorts(childS, 2);

37028
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

37029


37030
          /* port 0 */

37031
          {

37032
            real32_T const **sfcnUPtrs = (real32_T const **)

37033
              malloc(1 * sizeof(real32_T *));

37034
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37035
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

37036
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_e;

37037
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

37038
            _ssSetInputPortNumDimensions(childS, 0, 1);

37039
            ssSetInputPortWidth(childS, 0, 1);

37040
          }

37041


37042
          /* port 1 */

37043
          {

37044
            real32_T const **sfcnUPtrs = (real32_T const **)

37045
              malloc(1 * sizeof(real32_T *));

37046
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37047
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

37048
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

37049
            _ssSetInputPortNumDimensions(childS, 1, 1);

37050
            ssSetInputPortWidth(childS, 1, 1);

37051
          }

37052
        }

37053


37054
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

37055
          RegNumOutputPorts);

37056
        ssSetRegNumOutputPortsFcnArg(childS,childS);

37057


37058
        /* outputs */

37059
        {

37060
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

37061
            calloc(1, sizeof(struct _ssPortOutputs));

37062
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

37063
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

37064
          _ssSetNumOutputPorts(childS, 1);

37065


37066
          /* port 0 */

37067
          {

37068
            _ssSetOutputPortNumDimensions(childS, 0, 1);

37069
            ssSetOutputPortWidth(childS, 0, 1);

37070
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

37071
              ssGetLocalBlockIO(rts))->MinMax));

37072
          }

37073
        }

37074


37075
        /* path info */

37076
        _ssSetModelName(childS, "Gain_sf");

37077
        _ssSetPath(childS,

37078
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain/Generated S-Function");

37079
        if (ssGetRTModel(rts) == (NULL)) {

37080
          _ssSetParentSS(childS, rts);

37081
          _ssSetRootSS(childS, ssGetRootSS(rts));

37082
        } else {

37083
          ssSetRTModel(childS,ssGetRTModel(rts));

37084
          _ssSetParentSS(childS, (NULL));

37085
          _ssSetRootSS(childS, childS);

37086
        }

37087


37088
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

37089
        (childS)->regDataType.arg1 = ((void *)(childS));

37090
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

37091
          FcnSetErrorStatus);

37092
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

37093
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

37094
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

37095
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

37096


37097
        /* registration */

37098
#if defined(MATLAB_MEX_FILE)

37099


37100
        {

37101
          int_T i;

37102
          mxArray *plhs[1];

37103
          mxArray *prhs[4];

37104
          double *pr;

37105
          volatile int_T *intS = (int_T *)&childS;

37106
          int_T addrlen = sizeof(SimStruct *);

37107
          int_T m = addrlen/sizeof(int_T) + 1;

37108
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

37109
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

37110
          pr = mxGetPr(prhs[1]);

37111
          for (i = 0; i < m - 1; i++) {

37112
            pr[i] = (double)intS[i];

37113
          }

37114


37115
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

37116
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

37117
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

37118


37119
          /* Reset port dimensions info functions because the S-function

37120
           * and accelerator mex-files explicitly set their dimensions,

37121
           * i.e., they are not dynamically sized. For this case, the

37122
           * mex-file is responsible for the dimensions info memory

37123
           * and Simulink should not free it. This is achieved by

37124
           * setting the following two methods to NULL.

37125
           */

37126
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

37127
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

37128


37129
          /*

37130
           * Setup function pointers and call mdlInitializeSizes via

37131
           * simulink.c

37132
           */

37133
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

37134
          mxDestroyArray(plhs[0]);

37135
          mxDestroyArray(prhs[0]);

37136
          mxDestroyArray(prhs[1]);

37137
          mxDestroyArray(prhs[2]);

37138
          mxDestroyArray(prhs[3]);

37139
        }

37140


37141
#else

37142


37143
        {

37144
          Gain_sf(childS);

37145
          sfcnInitializeSizes(childS);

37146
        }

37147


37148
#endif

37149


37150
        sfcnInitializeSampleTimes(childS);

37151


37152
        /* adjust sample time */

37153
        ssSetSampleTime(childS, 0, 0.0);

37154
        ssSetOffsetTime(childS, 0, 0.0);

37155
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

37156


37157
        /* set compiled values of dynamic vector attributes */

37158
        ssSetNumNonsampledZCs(childS, 0);

37159


37160
        /* Update connectivity flags for each port */

37161
        _ssSetInputPortConnected(childS, 0, 1);

37162
        _ssSetInputPortConnected(childS, 1, 1);

37163
        _ssSetOutputPortConnected(childS, 0, 1);

37164
        _ssSetOutputPortBeingMerged(childS, 0, 0);

37165


37166
        /* Update the BufferDstPort flags for each input port */

37167
        _ssSetInputPortBufferDstPort(childS, 0, -1);

37168
        _ssSetInputPortBufferDstPort(childS, 1, -1);

37169
      }

37170


37171
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S260>/Generated S-Function (Gain_sf) */

37172
      {

37173
        SimStruct *childS = ssGetSFunction(rts, 140);

37174


37175
        /* timing info */

37176
        time_T *sfcnPeriod;

37177
        time_T *sfcnOffset;

37178
        int_T *sfcnTsMap;

37179
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

37180
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

37181
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

37182
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

37183
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

37184
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

37185
        (void) memset((void*)sfcnPeriod, 0,

37186
                      sizeof(time_T)*1);

37187
        (void) memset((void*)sfcnOffset, 0,

37188
                      sizeof(time_T)*1);

37189
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

37190
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

37191
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

37192


37193
        /* Set up the mdlInfo pointer */

37194
# ifdef USE_RTMODEL

37195


37196
        {

37197
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

37198
              struct _ssBlkInfo2));

37199
          ss_VALIDATE_MEMORY(rts,blkInfo2);

37200
          ssSetBlkInfo2Ptr(childS, blkInfo2);

37201
        }

37202


37203
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

37204


37205
# else

37206


37207
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

37208


37209
# endif                                /* USE_RTMODEL */

37210


37211
        /* Allocate memory of model methods 2 */

37212
        {

37213
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

37214
            malloc(sizeof(struct _ssSFcnModelMethods2));

37215
          ss_VALIDATE_MEMORY(rts,methods2);

37216
          ssSetModelMethods2(childS, methods2);

37217
        }

37218


37219
        /* Allocate memory of model methods 3 */

37220
        {

37221
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

37222
            malloc(sizeof(struct _ssSFcnModelMethods3));

37223
          ss_VALIDATE_MEMORY(rts,methods3);

37224
          ssSetModelMethods3(childS, methods3);

37225
        }

37226


37227
        /* Allocate memory for states auxilliary information */

37228
        {

37229
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

37230
            (sizeof(struct _ssStatesInfo2));

37231
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

37232
            malloc(sizeof(ssPeriodicStatesInfo));

37233
          ss_VALIDATE_MEMORY(rts,statesInfo2);

37234
          ssSetStatesInfo2(childS, statesInfo2);

37235
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

37236
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

37237
        }

37238


37239
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

37240
          RegNumInputPorts);

37241
        ssSetRegNumInputPortsFcnArg(childS,childS);

37242


37243
        /* inputs */

37244
        {

37245
          struct _ssPortInputs *inputPortInfo =

37246
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

37247
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

37248
          _ssSetNumInputPorts(childS, 2);

37249
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

37250


37251
          /* port 0 */

37252
          {

37253
            real32_T const **sfcnUPtrs = (real32_T const **)

37254
              malloc(1 * sizeof(real32_T *));

37255
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37256
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

37257
              ssGetLocalBlockIO(rts))->GeneratedSFunction4_ms;

37258
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

37259
            _ssSetInputPortNumDimensions(childS, 0, 1);

37260
            ssSetInputPortWidth(childS, 0, 1);

37261
          }

37262


37263
          /* port 1 */

37264
          {

37265
            real32_T const **sfcnUPtrs = (real32_T const **)

37266
              malloc(1 * sizeof(real32_T *));

37267
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37268
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;

37269
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

37270
            _ssSetInputPortNumDimensions(childS, 1, 1);

37271
            ssSetInputPortWidth(childS, 1, 1);

37272
          }

37273
        }

37274


37275
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

37276
          RegNumOutputPorts);

37277
        ssSetRegNumOutputPortsFcnArg(childS,childS);

37278


37279
        /* outputs */

37280
        {

37281
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

37282
            calloc(1, sizeof(struct _ssPortOutputs));

37283
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

37284
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

37285
          _ssSetNumOutputPorts(childS, 1);

37286


37287
          /* port 0 */

37288
          {

37289
            _ssSetOutputPortNumDimensions(childS, 0, 1);

37290
            ssSetOutputPortWidth(childS, 0, 1);

37291
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

37292
              ssGetLocalBlockIO(rts))->Saturation7));

37293
          }

37294
        }

37295


37296
        /* path info */

37297
        _ssSetModelName(childS, "Gain_sf");

37298
        _ssSetPath(childS,

37299
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain1/Generated S-Function");

37300
        if (ssGetRTModel(rts) == (NULL)) {

37301
          _ssSetParentSS(childS, rts);

37302
          _ssSetRootSS(childS, ssGetRootSS(rts));

37303
        } else {

37304
          ssSetRTModel(childS,ssGetRTModel(rts));

37305
          _ssSetParentSS(childS, (NULL));

37306
          _ssSetRootSS(childS, childS);

37307
        }

37308


37309
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

37310
        (childS)->regDataType.arg1 = ((void *)(childS));

37311
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

37312
          FcnSetErrorStatus);

37313
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

37314
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

37315
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

37316
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

37317


37318
        /* registration */

37319
#if defined(MATLAB_MEX_FILE)

37320


37321
        {

37322
          int_T i;

37323
          mxArray *plhs[1];

37324
          mxArray *prhs[4];

37325
          double *pr;

37326
          volatile int_T *intS = (int_T *)&childS;

37327
          int_T addrlen = sizeof(SimStruct *);

37328
          int_T m = addrlen/sizeof(int_T) + 1;

37329
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

37330
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

37331
          pr = mxGetPr(prhs[1]);

37332
          for (i = 0; i < m - 1; i++) {

37333
            pr[i] = (double)intS[i];

37334
          }

37335


37336
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

37337
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

37338
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

37339


37340
          /* Reset port dimensions info functions because the S-function

37341
           * and accelerator mex-files explicitly set their dimensions,

37342
           * i.e., they are not dynamically sized. For this case, the

37343
           * mex-file is responsible for the dimensions info memory

37344
           * and Simulink should not free it. This is achieved by

37345
           * setting the following two methods to NULL.

37346
           */

37347
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

37348
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

37349


37350
          /*

37351
           * Setup function pointers and call mdlInitializeSizes via

37352
           * simulink.c

37353
           */

37354
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

37355
          mxDestroyArray(plhs[0]);

37356
          mxDestroyArray(prhs[0]);

37357
          mxDestroyArray(prhs[1]);

37358
          mxDestroyArray(prhs[2]);

37359
          mxDestroyArray(prhs[3]);

37360
        }

37361


37362
#else

37363


37364
        {

37365
          Gain_sf(childS);

37366
          sfcnInitializeSizes(childS);

37367
        }

37368


37369
#endif

37370


37371
        sfcnInitializeSampleTimes(childS);

37372


37373
        /* adjust sample time */

37374
        ssSetSampleTime(childS, 0, 0.0);

37375
        ssSetOffsetTime(childS, 0, 0.0);

37376
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

37377


37378
        /* set compiled values of dynamic vector attributes */

37379
        ssSetNumNonsampledZCs(childS, 0);

37380


37381
        /* Update connectivity flags for each port */

37382
        _ssSetInputPortConnected(childS, 0, 1);

37383
        _ssSetInputPortConnected(childS, 1, 1);

37384
        _ssSetOutputPortConnected(childS, 0, 1);

37385
        _ssSetOutputPortBeingMerged(childS, 0, 0);

37386


37387
        /* Update the BufferDstPort flags for each input port */

37388
        _ssSetInputPortBufferDstPort(childS, 0, -1);

37389
        _ssSetInputPortBufferDstPort(childS, 1, -1);

37390
      }

37391


37392
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S255>/Generated S-Function9 (NegativePass_sf) */

37393
      {

37394
        SimStruct *childS = ssGetSFunction(rts, 141);

37395


37396
        /* timing info */

37397
        time_T *sfcnPeriod;

37398
        time_T *sfcnOffset;

37399
        int_T *sfcnTsMap;

37400
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

37401
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

37402
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

37403
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

37404
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

37405
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

37406
        (void) memset((void*)sfcnPeriod, 0,

37407
                      sizeof(time_T)*1);

37408
        (void) memset((void*)sfcnOffset, 0,

37409
                      sizeof(time_T)*1);

37410
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

37411
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

37412
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

37413


37414
        /* Set up the mdlInfo pointer */

37415
# ifdef USE_RTMODEL

37416


37417
        {

37418
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

37419
              struct _ssBlkInfo2));

37420
          ss_VALIDATE_MEMORY(rts,blkInfo2);

37421
          ssSetBlkInfo2Ptr(childS, blkInfo2);

37422
        }

37423


37424
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

37425


37426
# else

37427


37428
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

37429


37430
# endif                                /* USE_RTMODEL */

37431


37432
        /* Allocate memory of model methods 2 */

37433
        {

37434
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

37435
            malloc(sizeof(struct _ssSFcnModelMethods2));

37436
          ss_VALIDATE_MEMORY(rts,methods2);

37437
          ssSetModelMethods2(childS, methods2);

37438
        }

37439


37440
        /* Allocate memory of model methods 3 */

37441
        {

37442
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

37443
            malloc(sizeof(struct _ssSFcnModelMethods3));

37444
          ss_VALIDATE_MEMORY(rts,methods3);

37445
          ssSetModelMethods3(childS, methods3);

37446
        }

37447


37448
        /* Allocate memory for states auxilliary information */

37449
        {

37450
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

37451
            (sizeof(struct _ssStatesInfo2));

37452
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

37453
            malloc(sizeof(ssPeriodicStatesInfo));

37454
          ss_VALIDATE_MEMORY(rts,statesInfo2);

37455
          ssSetStatesInfo2(childS, statesInfo2);

37456
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

37457
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

37458
        }

37459


37460
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

37461
          RegNumInputPorts);

37462
        ssSetRegNumInputPortsFcnArg(childS,childS);

37463


37464
        /* inputs */

37465
        {

37466
          struct _ssPortInputs *inputPortInfo =

37467
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

37468
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

37469
          _ssSetNumInputPorts(childS, 1);

37470
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

37471


37472
          /* port 0 */

37473
          {

37474
            real32_T const **sfcnUPtrs = (real32_T const **)

37475
              malloc(1 * sizeof(real32_T *));

37476
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37477
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

37478
              ssGetLocalBlockIO(rts))->Sum2_hd;

37479
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

37480
            _ssSetInputPortNumDimensions(childS, 0, 1);

37481
            ssSetInputPortWidth(childS, 0, 1);

37482
          }

37483
        }

37484


37485
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

37486
          RegNumOutputPorts);

37487
        ssSetRegNumOutputPortsFcnArg(childS,childS);

37488


37489
        /* outputs */

37490
        {

37491
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

37492
            calloc(1, sizeof(struct _ssPortOutputs));

37493
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

37494
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

37495
          _ssSetNumOutputPorts(childS, 1);

37496


37497
          /* port 0 */

37498
          {

37499
            _ssSetOutputPortNumDimensions(childS, 0, 1);

37500
            ssSetOutputPortWidth(childS, 0, 1);

37501
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

37502
              ssGetLocalBlockIO(rts))->Saturation7));

37503
          }

37504
        }

37505


37506
        /* path info */

37507
        _ssSetModelName(childS, "NegativePass_sf");

37508
        _ssSetPath(childS,

37509
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ negative pass1/Generated S-Function9");

37510
        if (ssGetRTModel(rts) == (NULL)) {

37511
          _ssSetParentSS(childS, rts);

37512
          _ssSetRootSS(childS, ssGetRootSS(rts));

37513
        } else {

37514
          ssSetRTModel(childS,ssGetRTModel(rts));

37515
          _ssSetParentSS(childS, (NULL));

37516
          _ssSetRootSS(childS, childS);

37517
        }

37518


37519
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

37520
        (childS)->regDataType.arg1 = ((void *)(childS));

37521
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

37522
          FcnSetErrorStatus);

37523
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

37524
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

37525
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

37526
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

37527


37528
        /* registration */

37529
#if defined(MATLAB_MEX_FILE)

37530


37531
        {

37532
          int_T i;

37533
          mxArray *plhs[1];

37534
          mxArray *prhs[4];

37535
          double *pr;

37536
          volatile int_T *intS = (int_T *)&childS;

37537
          int_T addrlen = sizeof(SimStruct *);

37538
          int_T m = addrlen/sizeof(int_T) + 1;

37539
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

37540
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

37541
          pr = mxGetPr(prhs[1]);

37542
          for (i = 0; i < m - 1; i++) {

37543
            pr[i] = (double)intS[i];

37544
          }

37545


37546
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

37547
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

37548
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

37549


37550
          /* Reset port dimensions info functions because the S-function

37551
           * and accelerator mex-files explicitly set their dimensions,

37552
           * i.e., they are not dynamically sized. For this case, the

37553
           * mex-file is responsible for the dimensions info memory

37554
           * and Simulink should not free it. This is achieved by

37555
           * setting the following two methods to NULL.

37556
           */

37557
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

37558
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

37559


37560
          /*

37561
           * Setup function pointers and call mdlInitializeSizes via

37562
           * simulink.c

37563
           */

37564
          mexCallMATLAB(1, plhs, 4, prhs, "NegativePass_sf");

37565
          mxDestroyArray(plhs[0]);

37566
          mxDestroyArray(prhs[0]);

37567
          mxDestroyArray(prhs[1]);

37568
          mxDestroyArray(prhs[2]);

37569
          mxDestroyArray(prhs[3]);

37570
        }

37571


37572
#else

37573


37574
        {

37575
          NegativePass_sf(childS);

37576
          sfcnInitializeSizes(childS);

37577
        }

37578


37579
#endif

37580


37581
        sfcnInitializeSampleTimes(childS);

37582


37583
        /* adjust sample time */

37584
        ssSetSampleTime(childS, 0, 0.0);

37585
        ssSetOffsetTime(childS, 0, 0.0);

37586
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

37587


37588
        /* set compiled values of dynamic vector attributes */

37589
        ssSetNumNonsampledZCs(childS, 0);

37590


37591
        /* Update connectivity flags for each port */

37592
        _ssSetInputPortConnected(childS, 0, 1);

37593
        _ssSetOutputPortConnected(childS, 0, 1);

37594
        _ssSetOutputPortBeingMerged(childS, 0, 0);

37595


37596
        /* Update the BufferDstPort flags for each input port */

37597
        _ssSetInputPortBufferDstPort(childS, 0, -1);

37598
      }

37599


37600
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S266>/Generated S-Function (WashoutFilter_sf) */

37601
      {

37602
        SimStruct *childS = ssGetSFunction(rts, 142);

37603


37604
        /* timing info */

37605
        time_T *sfcnPeriod;

37606
        time_T *sfcnOffset;

37607
        int_T *sfcnTsMap;

37608
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

37609
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

37610
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

37611
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

37612
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

37613
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

37614
        (void) memset((void*)sfcnPeriod, 0,

37615
                      sizeof(time_T)*1);

37616
        (void) memset((void*)sfcnOffset, 0,

37617
                      sizeof(time_T)*1);

37618
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

37619
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

37620
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

37621


37622
        /* Set up the mdlInfo pointer */

37623
# ifdef USE_RTMODEL

37624


37625
        {

37626
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

37627
              struct _ssBlkInfo2));

37628
          ss_VALIDATE_MEMORY(rts,blkInfo2);

37629
          ssSetBlkInfo2Ptr(childS, blkInfo2);

37630
        }

37631


37632
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

37633


37634
# else

37635


37636
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

37637


37638
# endif                                /* USE_RTMODEL */

37639


37640
        /* Allocate memory of model methods 2 */

37641
        {

37642
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

37643
            malloc(sizeof(struct _ssSFcnModelMethods2));

37644
          ss_VALIDATE_MEMORY(rts,methods2);

37645
          ssSetModelMethods2(childS, methods2);

37646
        }

37647


37648
        /* Allocate memory of model methods 3 */

37649
        {

37650
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

37651
            malloc(sizeof(struct _ssSFcnModelMethods3));

37652
          ss_VALIDATE_MEMORY(rts,methods3);

37653
          ssSetModelMethods3(childS, methods3);

37654
        }

37655


37656
        /* Allocate memory for states auxilliary information */

37657
        {

37658
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

37659
            (sizeof(struct _ssStatesInfo2));

37660
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

37661
            malloc(sizeof(ssPeriodicStatesInfo));

37662
          ss_VALIDATE_MEMORY(rts,statesInfo2);

37663
          ssSetStatesInfo2(childS, statesInfo2);

37664
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

37665
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

37666
        }

37667


37668
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

37669
          RegNumInputPorts);

37670
        ssSetRegNumInputPortsFcnArg(childS,childS);

37671


37672
        /* inputs */

37673
        {

37674
          struct _ssPortInputs *inputPortInfo =

37675
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

37676
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

37677
          _ssSetNumInputPorts(childS, 6);

37678
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

37679


37680
          /* port 0 */

37681
          {

37682
            real32_T const **sfcnUPtrs = (real32_T const **)

37683
              malloc(1 * sizeof(real32_T *));

37684
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37685
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

37686
              ssGetLocalBlockIO(rts))->dtCAS;

37687
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

37688
            _ssSetInputPortNumDimensions(childS, 0, 1);

37689
            ssSetInputPortWidth(childS, 0, 1);

37690
          }

37691


37692
          /* port 1 */

37693
          {

37694
            int8_T const **sfcnUPtrs = (int8_T const **)

37695
              malloc(1 * sizeof(int8_T *));

37696
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37697
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

37698
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

37699
            _ssSetInputPortNumDimensions(childS, 1, 1);

37700
            ssSetInputPortWidth(childS, 1, 1);

37701
          }

37702


37703
          /* port 2 */

37704
          {

37705
            real32_T const **sfcnUPtrs = (real32_T const **)

37706
              malloc(1 * sizeof(real32_T *));

37707
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37708
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

37709
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

37710
            _ssSetInputPortNumDimensions(childS, 2, 1);

37711
            ssSetInputPortWidth(childS, 2, 1);

37712
          }

37713


37714
          /* port 3 */

37715
          {

37716
            real32_T const **sfcnUPtrs = (real32_T const **)

37717
              malloc(1 * sizeof(real32_T *));

37718
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37719
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

37720
              ssGetLocalBlockIO(rts))->Alfa_j;

37721
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

37722
            _ssSetInputPortNumDimensions(childS, 3, 1);

37723
            ssSetInputPortWidth(childS, 3, 1);

37724
          }

37725


37726
          /* port 4 */

37727
          {

37728
            real32_T const **sfcnUPtrs = (real32_T const **)

37729
              malloc(1 * sizeof(real32_T *));

37730
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37731
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

37732
              ssGetLocalBlockIO(rts))->Alfa_j;

37733
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

37734
            _ssSetInputPortNumDimensions(childS, 4, 1);

37735
            ssSetInputPortWidth(childS, 4, 1);

37736
          }

37737


37738
          /* port 5 */

37739
          {

37740
            real32_T const **sfcnUPtrs = (real32_T const **)

37741
              malloc(1 * sizeof(real32_T *));

37742
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

37743
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

37744
              ssGetLocalBlockIO(rts))->Alfa_j;

37745
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

37746
            _ssSetInputPortNumDimensions(childS, 5, 1);

37747
            ssSetInputPortWidth(childS, 5, 1);

37748
          }

37749
        }

37750


37751
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

37752
          RegNumOutputPorts);

37753
        ssSetRegNumOutputPortsFcnArg(childS,childS);

37754


37755
        /* outputs */

37756
        {

37757
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

37758
            calloc(1, sizeof(struct _ssPortOutputs));

37759
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

37760
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

37761
          _ssSetNumOutputPorts(childS, 1);

37762


37763
          /* port 0 */

37764
          {

37765
            _ssSetOutputPortNumDimensions(childS, 0, 1);

37766
            ssSetOutputPortWidth(childS, 0, 1);

37767
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

37768
              ssGetLocalBlockIO(rts))->GeneratedSFunction_f5));

37769
          }

37770
        }

37771


37772
        /* path info */

37773
        _ssSetModelName(childS, "WashoutFilter_sf");

37774
        _ssSetPath(childS,

37775
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim / high pass filter2/Generated S-Function");

37776
        if (ssGetRTModel(rts) == (NULL)) {

37777
          _ssSetParentSS(childS, rts);

37778
          _ssSetRootSS(childS, ssGetRootSS(rts));

37779
        } else {

37780
          ssSetRTModel(childS,ssGetRTModel(rts));

37781
          _ssSetParentSS(childS, (NULL));

37782
          _ssSetRootSS(childS, childS);

37783
        }

37784


37785
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

37786


37787
        /* work vectors */

37788
        {

37789
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

37790
            (4 * sizeof(struct _ssDWorkRecord));

37791
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

37792
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

37793
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

37794
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

37795
          ssSetSFcnDWork(childS, dWorkRecord);

37796
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

37797
          _ssSetNumDWork(childS, 4);

37798


37799
          /* DWORK0 */

37800
          ssSetDWorkWidth(childS, 0, 1);

37801
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

37802
          ssSetDWorkComplexSignal(childS, 0, 0);

37803
          ssSetDWorkUsedAsDState(childS, 0, 1);

37804
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 257))[0]);

37805


37806
          /* DWORK1 */

37807
          ssSetDWorkWidth(childS, 1, 1);

37808
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

37809
          ssSetDWorkComplexSignal(childS, 1, 0);

37810
          ssSetDWorkUsedAsDState(childS, 1, 1);

37811
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 258))[0]);

37812


37813
          /* DWORK2 */

37814
          ssSetDWorkWidth(childS, 2, 1);

37815
          ssSetDWorkDataType(childS, 2,SS_INT8);

37816
          ssSetDWorkComplexSignal(childS, 2, 0);

37817
          ssSetDWorkUsedAsDState(childS, 2, 1);

37818
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 487))[0]);

37819


37820
          /* DWORK3 */

37821
          ssSetDWorkWidth(childS, 3, 1);

37822
          ssSetDWorkDataType(childS, 3,SS_INT8);

37823
          ssSetDWorkComplexSignal(childS, 3, 0);

37824
          ssSetDWorkUsedAsDState(childS, 3, 1);

37825
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 488))[0]);

37826
        }

37827


37828
        (childS)->regDataType.arg1 = ((void *)(childS));

37829
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

37830
          FcnSetErrorStatus);

37831
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

37832
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

37833
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

37834
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

37835


37836
        /* registration */

37837
#if defined(MATLAB_MEX_FILE)

37838


37839
        {

37840
          int_T i;

37841
          mxArray *plhs[1];

37842
          mxArray *prhs[4];

37843
          double *pr;

37844
          volatile int_T *intS = (int_T *)&childS;

37845
          int_T addrlen = sizeof(SimStruct *);

37846
          int_T m = addrlen/sizeof(int_T) + 1;

37847
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

37848
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

37849
          pr = mxGetPr(prhs[1]);

37850
          for (i = 0; i < m - 1; i++) {

37851
            pr[i] = (double)intS[i];

37852
          }

37853


37854
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

37855
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

37856
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

37857


37858
          /* Reset port dimensions info functions because the S-function

37859
           * and accelerator mex-files explicitly set their dimensions,

37860
           * i.e., they are not dynamically sized. For this case, the

37861
           * mex-file is responsible for the dimensions info memory

37862
           * and Simulink should not free it. This is achieved by

37863
           * setting the following two methods to NULL.

37864
           */

37865
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

37866
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

37867


37868
          /*

37869
           * Setup function pointers and call mdlInitializeSizes via

37870
           * simulink.c

37871
           */

37872
          mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");

37873
          mxDestroyArray(plhs[0]);

37874
          mxDestroyArray(prhs[0]);

37875
          mxDestroyArray(prhs[1]);

37876
          mxDestroyArray(prhs[2]);

37877
          mxDestroyArray(prhs[3]);

37878
        }

37879


37880
#else

37881


37882
        {

37883
          WashoutFilter_sf(childS);

37884
          sfcnInitializeSizes(childS);

37885
        }

37886


37887
#endif

37888


37889
        sfcnInitializeSampleTimes(childS);

37890


37891
        /* adjust sample time */

37892
        ssSetSampleTime(childS, 0, 0.0);

37893
        ssSetOffsetTime(childS, 0, 0.0);

37894
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

37895


37896
        /* set compiled values of dynamic vector attributes */

37897
        ssSetNumNonsampledZCs(childS, 0);

37898


37899
        /* Update connectivity flags for each port */

37900
        _ssSetInputPortConnected(childS, 0, 1);

37901
        _ssSetInputPortConnected(childS, 1, 1);

37902
        _ssSetInputPortConnected(childS, 2, 1);

37903
        _ssSetInputPortConnected(childS, 3, 1);

37904
        _ssSetInputPortConnected(childS, 4, 1);

37905
        _ssSetInputPortConnected(childS, 5, 1);

37906
        _ssSetOutputPortConnected(childS, 0, 1);

37907
        _ssSetOutputPortBeingMerged(childS, 0, 0);

37908


37909
        /* Update the BufferDstPort flags for each input port */

37910
        _ssSetInputPortBufferDstPort(childS, 0, -1);

37911
        _ssSetInputPortBufferDstPort(childS, 1, -1);

37912
        _ssSetInputPortBufferDstPort(childS, 2, -1);

37913
        _ssSetInputPortBufferDstPort(childS, 3, -1);

37914
        _ssSetInputPortBufferDstPort(childS, 4, -1);

37915
        _ssSetInputPortBufferDstPort(childS, 5, -1);

37916
      }

37917


37918
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S268>/Generated S-Function (Gain_sf) */

37919
      {

37920
        SimStruct *childS = ssGetSFunction(rts, 143);

37921


37922
        /* timing info */

37923
        time_T *sfcnPeriod;

37924
        time_T *sfcnOffset;

37925
        int_T *sfcnTsMap;

37926
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

37927
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

37928
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

37929
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

37930
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

37931
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

37932
        (void) memset((void*)sfcnPeriod, 0,

37933
                      sizeof(time_T)*1);

37934
        (void) memset((void*)sfcnOffset, 0,

37935
                      sizeof(time_T)*1);

37936
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

37937
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

37938
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

37939


37940
        /* Set up the mdlInfo pointer */

37941
# ifdef USE_RTMODEL

37942


37943
        {

37944
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

37945
              struct _ssBlkInfo2));

37946
          ss_VALIDATE_MEMORY(rts,blkInfo2);

37947
          ssSetBlkInfo2Ptr(childS, blkInfo2);

37948
        }

37949


37950
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

37951


37952
# else

37953


37954
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

37955


37956
# endif                                /* USE_RTMODEL */

37957


37958
        /* Allocate memory of model methods 2 */

37959
        {

37960
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

37961
            malloc(sizeof(struct _ssSFcnModelMethods2));

37962
          ss_VALIDATE_MEMORY(rts,methods2);

37963
          ssSetModelMethods2(childS, methods2);

37964
        }

37965


37966
        /* Allocate memory of model methods 3 */

37967
        {

37968
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

37969
            malloc(sizeof(struct _ssSFcnModelMethods3));

37970
          ss_VALIDATE_MEMORY(rts,methods3);

37971
          ssSetModelMethods3(childS, methods3);

37972
        }

37973


37974
        /* Allocate memory for states auxilliary information */

37975
        {

37976
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

37977
            (sizeof(struct _ssStatesInfo2));

37978
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

37979
            malloc(sizeof(ssPeriodicStatesInfo));

37980
          ss_VALIDATE_MEMORY(rts,statesInfo2);

37981
          ssSetStatesInfo2(childS, statesInfo2);

37982
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

37983
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

37984
        }

37985


37986
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

37987
          RegNumInputPorts);

37988
        ssSetRegNumInputPortsFcnArg(childS,childS);

37989


37990
        /* inputs */

37991
        {

37992
          struct _ssPortInputs *inputPortInfo =

37993
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

37994
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

37995
          _ssSetNumInputPorts(childS, 2);

37996
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

37997


37998
          /* port 0 */

37999
          {

38000
            real32_T const **sfcnUPtrs = (real32_T const **)

38001
              malloc(1 * sizeof(real32_T *));

38002
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38003
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38004
              ssGetLocalBlockIO(rts))->GeneratedSFunction_f5;

38005
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

38006
            _ssSetInputPortNumDimensions(childS, 0, 1);

38007
            ssSetInputPortWidth(childS, 0, 1);

38008
          }

38009


38010
          /* port 1 */

38011
          {

38012
            real32_T const **sfcnUPtrs = (real32_T const **)

38013
              malloc(1 * sizeof(real32_T *));

38014
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38015
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;

38016
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

38017
            _ssSetInputPortNumDimensions(childS, 1, 1);

38018
            ssSetInputPortWidth(childS, 1, 1);

38019
          }

38020
        }

38021


38022
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

38023
          RegNumOutputPorts);

38024
        ssSetRegNumOutputPortsFcnArg(childS,childS);

38025


38026
        /* outputs */

38027
        {

38028
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

38029
            calloc(1, sizeof(struct _ssPortOutputs));

38030
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

38031
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

38032
          _ssSetNumOutputPorts(childS, 1);

38033


38034
          /* port 0 */

38035
          {

38036
            _ssSetOutputPortNumDimensions(childS, 0, 1);

38037
            ssSetOutputPortWidth(childS, 0, 1);

38038
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

38039
              ssGetLocalBlockIO(rts))->MinMax));

38040
          }

38041
        }

38042


38043
        /* path info */

38044
        _ssSetModelName(childS, "Gain_sf");

38045
        _ssSetPath(childS,

38046
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain1/Generated S-Function");

38047
        if (ssGetRTModel(rts) == (NULL)) {

38048
          _ssSetParentSS(childS, rts);

38049
          _ssSetRootSS(childS, ssGetRootSS(rts));

38050
        } else {

38051
          ssSetRTModel(childS,ssGetRTModel(rts));

38052
          _ssSetParentSS(childS, (NULL));

38053
          _ssSetRootSS(childS, childS);

38054
        }

38055


38056
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

38057
        (childS)->regDataType.arg1 = ((void *)(childS));

38058
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

38059
          FcnSetErrorStatus);

38060
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

38061
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

38062
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

38063
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

38064


38065
        /* registration */

38066
#if defined(MATLAB_MEX_FILE)

38067


38068
        {

38069
          int_T i;

38070
          mxArray *plhs[1];

38071
          mxArray *prhs[4];

38072
          double *pr;

38073
          volatile int_T *intS = (int_T *)&childS;

38074
          int_T addrlen = sizeof(SimStruct *);

38075
          int_T m = addrlen/sizeof(int_T) + 1;

38076
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

38077
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

38078
          pr = mxGetPr(prhs[1]);

38079
          for (i = 0; i < m - 1; i++) {

38080
            pr[i] = (double)intS[i];

38081
          }

38082


38083
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

38084
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

38085
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

38086


38087
          /* Reset port dimensions info functions because the S-function

38088
           * and accelerator mex-files explicitly set their dimensions,

38089
           * i.e., they are not dynamically sized. For this case, the

38090
           * mex-file is responsible for the dimensions info memory

38091
           * and Simulink should not free it. This is achieved by

38092
           * setting the following two methods to NULL.

38093
           */

38094
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

38095
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

38096


38097
          /*

38098
           * Setup function pointers and call mdlInitializeSizes via

38099
           * simulink.c

38100
           */

38101
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

38102
          mxDestroyArray(plhs[0]);

38103
          mxDestroyArray(prhs[0]);

38104
          mxDestroyArray(prhs[1]);

38105
          mxDestroyArray(prhs[2]);

38106
          mxDestroyArray(prhs[3]);

38107
        }

38108


38109
#else

38110


38111
        {

38112
          Gain_sf(childS);

38113
          sfcnInitializeSizes(childS);

38114
        }

38115


38116
#endif

38117


38118
        sfcnInitializeSampleTimes(childS);

38119


38120
        /* adjust sample time */

38121
        ssSetSampleTime(childS, 0, 0.0);

38122
        ssSetOffsetTime(childS, 0, 0.0);

38123
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

38124


38125
        /* set compiled values of dynamic vector attributes */

38126
        ssSetNumNonsampledZCs(childS, 0);

38127


38128
        /* Update connectivity flags for each port */

38129
        _ssSetInputPortConnected(childS, 0, 1);

38130
        _ssSetInputPortConnected(childS, 1, 1);

38131
        _ssSetOutputPortConnected(childS, 0, 1);

38132
        _ssSetOutputPortBeingMerged(childS, 0, 0);

38133


38134
        /* Update the BufferDstPort flags for each input port */

38135
        _ssSetInputPortBufferDstPort(childS, 0, -1);

38136
        _ssSetInputPortBufferDstPort(childS, 1, -1);

38137
      }

38138


38139
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S265>/Generated S-Function8 (WashoutFilter_sf) */

38140
      {

38141
        SimStruct *childS = ssGetSFunction(rts, 144);

38142


38143
        /* timing info */

38144
        time_T *sfcnPeriod;

38145
        time_T *sfcnOffset;

38146
        int_T *sfcnTsMap;

38147
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

38148
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

38149
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

38150
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

38151
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

38152
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

38153
        (void) memset((void*)sfcnPeriod, 0,

38154
                      sizeof(time_T)*1);

38155
        (void) memset((void*)sfcnOffset, 0,

38156
                      sizeof(time_T)*1);

38157
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

38158
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

38159
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

38160


38161
        /* Set up the mdlInfo pointer */

38162
# ifdef USE_RTMODEL

38163


38164
        {

38165
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

38166
              struct _ssBlkInfo2));

38167
          ss_VALIDATE_MEMORY(rts,blkInfo2);

38168
          ssSetBlkInfo2Ptr(childS, blkInfo2);

38169
        }

38170


38171
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

38172


38173
# else

38174


38175
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

38176


38177
# endif                                /* USE_RTMODEL */

38178


38179
        /* Allocate memory of model methods 2 */

38180
        {

38181
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

38182
            malloc(sizeof(struct _ssSFcnModelMethods2));

38183
          ss_VALIDATE_MEMORY(rts,methods2);

38184
          ssSetModelMethods2(childS, methods2);

38185
        }

38186


38187
        /* Allocate memory of model methods 3 */

38188
        {

38189
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

38190
            malloc(sizeof(struct _ssSFcnModelMethods3));

38191
          ss_VALIDATE_MEMORY(rts,methods3);

38192
          ssSetModelMethods3(childS, methods3);

38193
        }

38194


38195
        /* Allocate memory for states auxilliary information */

38196
        {

38197
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

38198
            (sizeof(struct _ssStatesInfo2));

38199
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

38200
            malloc(sizeof(ssPeriodicStatesInfo));

38201
          ss_VALIDATE_MEMORY(rts,statesInfo2);

38202
          ssSetStatesInfo2(childS, statesInfo2);

38203
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

38204
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

38205
        }

38206


38207
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

38208
          RegNumInputPorts);

38209
        ssSetRegNumInputPortsFcnArg(childS,childS);

38210


38211
        /* inputs */

38212
        {

38213
          struct _ssPortInputs *inputPortInfo =

38214
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

38215
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

38216
          _ssSetNumInputPorts(childS, 6);

38217
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

38218


38219
          /* port 0 */

38220
          {

38221
            real32_T const **sfcnUPtrs = (real32_T const **)

38222
              malloc(1 * sizeof(real32_T *));

38223
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38224
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38225
              ssGetLocalBlockIO(rts))->dtCAS;

38226
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

38227
            _ssSetInputPortNumDimensions(childS, 0, 1);

38228
            ssSetInputPortWidth(childS, 0, 1);

38229
          }

38230


38231
          /* port 1 */

38232
          {

38233
            int8_T const **sfcnUPtrs = (int8_T const **)

38234
              malloc(1 * sizeof(int8_T *));

38235
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38236
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

38237
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

38238
            _ssSetInputPortNumDimensions(childS, 1, 1);

38239
            ssSetInputPortWidth(childS, 1, 1);

38240
          }

38241


38242
          /* port 2 */

38243
          {

38244
            real32_T const **sfcnUPtrs = (real32_T const **)

38245
              malloc(1 * sizeof(real32_T *));

38246
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38247
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;

38248
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

38249
            _ssSetInputPortNumDimensions(childS, 2, 1);

38250
            ssSetInputPortWidth(childS, 2, 1);

38251
          }

38252


38253
          /* port 3 */

38254
          {

38255
            real32_T const **sfcnUPtrs = (real32_T const **)

38256
              malloc(1 * sizeof(real32_T *));

38257
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38258
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38259
              ssGetLocalBlockIO(rts))->q_k;

38260
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

38261
            _ssSetInputPortNumDimensions(childS, 3, 1);

38262
            ssSetInputPortWidth(childS, 3, 1);

38263
          }

38264


38265
          /* port 4 */

38266
          {

38267
            real32_T const **sfcnUPtrs = (real32_T const **)

38268
              malloc(1 * sizeof(real32_T *));

38269
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38270
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38271
              ssGetLocalBlockIO(rts))->q_k;

38272
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

38273
            _ssSetInputPortNumDimensions(childS, 4, 1);

38274
            ssSetInputPortWidth(childS, 4, 1);

38275
          }

38276


38277
          /* port 5 */

38278
          {

38279
            real32_T const **sfcnUPtrs = (real32_T const **)

38280
              malloc(1 * sizeof(real32_T *));

38281
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38282
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38283
              ssGetLocalBlockIO(rts))->q_k;

38284
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

38285
            _ssSetInputPortNumDimensions(childS, 5, 1);

38286
            ssSetInputPortWidth(childS, 5, 1);

38287
          }

38288
        }

38289


38290
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

38291
          RegNumOutputPorts);

38292
        ssSetRegNumOutputPortsFcnArg(childS,childS);

38293


38294
        /* outputs */

38295
        {

38296
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

38297
            calloc(1, sizeof(struct _ssPortOutputs));

38298
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

38299
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

38300
          _ssSetNumOutputPorts(childS, 1);

38301


38302
          /* port 0 */

38303
          {

38304
            _ssSetOutputPortNumDimensions(childS, 0, 1);

38305
            ssSetOutputPortWidth(childS, 0, 1);

38306
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

38307
              ssGetLocalBlockIO(rts))->GeneratedSFunction8_e));

38308
          }

38309
        }

38310


38311
        /* path info */

38312
        _ssSetModelName(childS, "WashoutFilter_sf");

38313
        _ssSetPath(childS,

38314
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim / high pass filter1/Generated S-Function8");

38315
        if (ssGetRTModel(rts) == (NULL)) {

38316
          _ssSetParentSS(childS, rts);

38317
          _ssSetRootSS(childS, ssGetRootSS(rts));

38318
        } else {

38319
          ssSetRTModel(childS,ssGetRTModel(rts));

38320
          _ssSetParentSS(childS, (NULL));

38321
          _ssSetRootSS(childS, childS);

38322
        }

38323


38324
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

38325


38326
        /* work vectors */

38327
        {

38328
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

38329
            (4 * sizeof(struct _ssDWorkRecord));

38330
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

38331
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

38332
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

38333
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

38334
          ssSetSFcnDWork(childS, dWorkRecord);

38335
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

38336
          _ssSetNumDWork(childS, 4);

38337


38338
          /* DWORK0 */

38339
          ssSetDWorkWidth(childS, 0, 1);

38340
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

38341
          ssSetDWorkComplexSignal(childS, 0, 0);

38342
          ssSetDWorkUsedAsDState(childS, 0, 1);

38343
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 259))[0]);

38344


38345
          /* DWORK1 */

38346
          ssSetDWorkWidth(childS, 1, 1);

38347
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

38348
          ssSetDWorkComplexSignal(childS, 1, 0);

38349
          ssSetDWorkUsedAsDState(childS, 1, 1);

38350
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 260))[0]);

38351


38352
          /* DWORK2 */

38353
          ssSetDWorkWidth(childS, 2, 1);

38354
          ssSetDWorkDataType(childS, 2,SS_INT8);

38355
          ssSetDWorkComplexSignal(childS, 2, 0);

38356
          ssSetDWorkUsedAsDState(childS, 2, 1);

38357
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 489))[0]);

38358


38359
          /* DWORK3 */

38360
          ssSetDWorkWidth(childS, 3, 1);

38361
          ssSetDWorkDataType(childS, 3,SS_INT8);

38362
          ssSetDWorkComplexSignal(childS, 3, 0);

38363
          ssSetDWorkUsedAsDState(childS, 3, 1);

38364
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 490))[0]);

38365
        }

38366


38367
        (childS)->regDataType.arg1 = ((void *)(childS));

38368
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

38369
          FcnSetErrorStatus);

38370
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

38371
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

38372
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

38373
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

38374


38375
        /* registration */

38376
#if defined(MATLAB_MEX_FILE)

38377


38378
        {

38379
          int_T i;

38380
          mxArray *plhs[1];

38381
          mxArray *prhs[4];

38382
          double *pr;

38383
          volatile int_T *intS = (int_T *)&childS;

38384
          int_T addrlen = sizeof(SimStruct *);

38385
          int_T m = addrlen/sizeof(int_T) + 1;

38386
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

38387
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

38388
          pr = mxGetPr(prhs[1]);

38389
          for (i = 0; i < m - 1; i++) {

38390
            pr[i] = (double)intS[i];

38391
          }

38392


38393
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

38394
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

38395
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

38396


38397
          /* Reset port dimensions info functions because the S-function

38398
           * and accelerator mex-files explicitly set their dimensions,

38399
           * i.e., they are not dynamically sized. For this case, the

38400
           * mex-file is responsible for the dimensions info memory

38401
           * and Simulink should not free it. This is achieved by

38402
           * setting the following two methods to NULL.

38403
           */

38404
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

38405
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

38406


38407
          /*

38408
           * Setup function pointers and call mdlInitializeSizes via

38409
           * simulink.c

38410
           */

38411
          mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");

38412
          mxDestroyArray(plhs[0]);

38413
          mxDestroyArray(prhs[0]);

38414
          mxDestroyArray(prhs[1]);

38415
          mxDestroyArray(prhs[2]);

38416
          mxDestroyArray(prhs[3]);

38417
        }

38418


38419
#else

38420


38421
        {

38422
          WashoutFilter_sf(childS);

38423
          sfcnInitializeSizes(childS);

38424
        }

38425


38426
#endif

38427


38428
        sfcnInitializeSampleTimes(childS);

38429


38430
        /* adjust sample time */

38431
        ssSetSampleTime(childS, 0, 0.0);

38432
        ssSetOffsetTime(childS, 0, 0.0);

38433
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

38434


38435
        /* set compiled values of dynamic vector attributes */

38436
        ssSetNumNonsampledZCs(childS, 0);

38437


38438
        /* Update connectivity flags for each port */

38439
        _ssSetInputPortConnected(childS, 0, 1);

38440
        _ssSetInputPortConnected(childS, 1, 1);

38441
        _ssSetInputPortConnected(childS, 2, 1);

38442
        _ssSetInputPortConnected(childS, 3, 1);

38443
        _ssSetInputPortConnected(childS, 4, 1);

38444
        _ssSetInputPortConnected(childS, 5, 1);

38445
        _ssSetOutputPortConnected(childS, 0, 1);

38446
        _ssSetOutputPortBeingMerged(childS, 0, 0);

38447


38448
        /* Update the BufferDstPort flags for each input port */

38449
        _ssSetInputPortBufferDstPort(childS, 0, -1);

38450
        _ssSetInputPortBufferDstPort(childS, 1, -1);

38451
        _ssSetInputPortBufferDstPort(childS, 2, -1);

38452
        _ssSetInputPortBufferDstPort(childS, 3, -1);

38453
        _ssSetInputPortBufferDstPort(childS, 4, -1);

38454
        _ssSetInputPortBufferDstPort(childS, 5, -1);

38455
      }

38456


38457
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S269>/Generated S-Function (Gain_sf) */

38458
      {

38459
        SimStruct *childS = ssGetSFunction(rts, 145);

38460


38461
        /* timing info */

38462
        time_T *sfcnPeriod;

38463
        time_T *sfcnOffset;

38464
        int_T *sfcnTsMap;

38465
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

38466
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

38467
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

38468
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

38469
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

38470
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

38471
        (void) memset((void*)sfcnPeriod, 0,

38472
                      sizeof(time_T)*1);

38473
        (void) memset((void*)sfcnOffset, 0,

38474
                      sizeof(time_T)*1);

38475
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

38476
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

38477
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

38478


38479
        /* Set up the mdlInfo pointer */

38480
# ifdef USE_RTMODEL

38481


38482
        {

38483
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

38484
              struct _ssBlkInfo2));

38485
          ss_VALIDATE_MEMORY(rts,blkInfo2);

38486
          ssSetBlkInfo2Ptr(childS, blkInfo2);

38487
        }

38488


38489
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

38490


38491
# else

38492


38493
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

38494


38495
# endif                                /* USE_RTMODEL */

38496


38497
        /* Allocate memory of model methods 2 */

38498
        {

38499
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

38500
            malloc(sizeof(struct _ssSFcnModelMethods2));

38501
          ss_VALIDATE_MEMORY(rts,methods2);

38502
          ssSetModelMethods2(childS, methods2);

38503
        }

38504


38505
        /* Allocate memory of model methods 3 */

38506
        {

38507
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

38508
            malloc(sizeof(struct _ssSFcnModelMethods3));

38509
          ss_VALIDATE_MEMORY(rts,methods3);

38510
          ssSetModelMethods3(childS, methods3);

38511
        }

38512


38513
        /* Allocate memory for states auxilliary information */

38514
        {

38515
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

38516
            (sizeof(struct _ssStatesInfo2));

38517
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

38518
            malloc(sizeof(ssPeriodicStatesInfo));

38519
          ss_VALIDATE_MEMORY(rts,statesInfo2);

38520
          ssSetStatesInfo2(childS, statesInfo2);

38521
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

38522
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

38523
        }

38524


38525
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

38526
          RegNumInputPorts);

38527
        ssSetRegNumInputPortsFcnArg(childS,childS);

38528


38529
        /* inputs */

38530
        {

38531
          struct _ssPortInputs *inputPortInfo =

38532
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

38533
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

38534
          _ssSetNumInputPorts(childS, 2);

38535
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

38536


38537
          /* port 0 */

38538
          {

38539
            real32_T const **sfcnUPtrs = (real32_T const **)

38540
              malloc(1 * sizeof(real32_T *));

38541
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38542
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38543
              ssGetLocalBlockIO(rts))->GeneratedSFunction8_e;

38544
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

38545
            _ssSetInputPortNumDimensions(childS, 0, 1);

38546
            ssSetInputPortWidth(childS, 0, 1);

38547
          }

38548


38549
          /* port 1 */

38550
          {

38551
            real32_T const **sfcnUPtrs = (real32_T const **)

38552
              malloc(1 * sizeof(real32_T *));

38553
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38554
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled133;

38555
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

38556
            _ssSetInputPortNumDimensions(childS, 1, 1);

38557
            ssSetInputPortWidth(childS, 1, 1);

38558
          }

38559
        }

38560


38561
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

38562
          RegNumOutputPorts);

38563
        ssSetRegNumOutputPortsFcnArg(childS,childS);

38564


38565
        /* outputs */

38566
        {

38567
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

38568
            calloc(1, sizeof(struct _ssPortOutputs));

38569
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

38570
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

38571
          _ssSetNumOutputPorts(childS, 1);

38572


38573
          /* port 0 */

38574
          {

38575
            _ssSetOutputPortNumDimensions(childS, 0, 1);

38576
            ssSetOutputPortWidth(childS, 0, 1);

38577
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

38578
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));

38579
          }

38580
        }

38581


38582
        /* path info */

38583
        _ssSetModelName(childS, "Gain_sf");

38584
        _ssSetPath(childS,

38585
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain10/Generated S-Function");

38586
        if (ssGetRTModel(rts) == (NULL)) {

38587
          _ssSetParentSS(childS, rts);

38588
          _ssSetRootSS(childS, ssGetRootSS(rts));

38589
        } else {

38590
          ssSetRTModel(childS,ssGetRTModel(rts));

38591
          _ssSetParentSS(childS, (NULL));

38592
          _ssSetRootSS(childS, childS);

38593
        }

38594


38595
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

38596
        (childS)->regDataType.arg1 = ((void *)(childS));

38597
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

38598
          FcnSetErrorStatus);

38599
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

38600
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

38601
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

38602
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

38603


38604
        /* registration */

38605
#if defined(MATLAB_MEX_FILE)

38606


38607
        {

38608
          int_T i;

38609
          mxArray *plhs[1];

38610
          mxArray *prhs[4];

38611
          double *pr;

38612
          volatile int_T *intS = (int_T *)&childS;

38613
          int_T addrlen = sizeof(SimStruct *);

38614
          int_T m = addrlen/sizeof(int_T) + 1;

38615
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

38616
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

38617
          pr = mxGetPr(prhs[1]);

38618
          for (i = 0; i < m - 1; i++) {

38619
            pr[i] = (double)intS[i];

38620
          }

38621


38622
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

38623
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

38624
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

38625


38626
          /* Reset port dimensions info functions because the S-function

38627
           * and accelerator mex-files explicitly set their dimensions,

38628
           * i.e., they are not dynamically sized. For this case, the

38629
           * mex-file is responsible for the dimensions info memory

38630
           * and Simulink should not free it. This is achieved by

38631
           * setting the following two methods to NULL.

38632
           */

38633
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

38634
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

38635


38636
          /*

38637
           * Setup function pointers and call mdlInitializeSizes via

38638
           * simulink.c

38639
           */

38640
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

38641
          mxDestroyArray(plhs[0]);

38642
          mxDestroyArray(prhs[0]);

38643
          mxDestroyArray(prhs[1]);

38644
          mxDestroyArray(prhs[2]);

38645
          mxDestroyArray(prhs[3]);

38646
        }

38647


38648
#else

38649


38650
        {

38651
          Gain_sf(childS);

38652
          sfcnInitializeSizes(childS);

38653
        }

38654


38655
#endif

38656


38657
        sfcnInitializeSampleTimes(childS);

38658


38659
        /* adjust sample time */

38660
        ssSetSampleTime(childS, 0, 0.0);

38661
        ssSetOffsetTime(childS, 0, 0.0);

38662
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

38663


38664
        /* set compiled values of dynamic vector attributes */

38665
        ssSetNumNonsampledZCs(childS, 0);

38666


38667
        /* Update connectivity flags for each port */

38668
        _ssSetInputPortConnected(childS, 0, 1);

38669
        _ssSetInputPortConnected(childS, 1, 1);

38670
        _ssSetOutputPortConnected(childS, 0, 1);

38671
        _ssSetOutputPortBeingMerged(childS, 0, 0);

38672


38673
        /* Update the BufferDstPort flags for each input port */

38674
        _ssSetInputPortBufferDstPort(childS, 0, -1);

38675
        _ssSetInputPortBufferDstPort(childS, 1, -1);

38676
      }

38677


38678
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S267>/Generated S-Function (NegativePass_sf) */

38679
      {

38680
        SimStruct *childS = ssGetSFunction(rts, 146);

38681


38682
        /* timing info */

38683
        time_T *sfcnPeriod;

38684
        time_T *sfcnOffset;

38685
        int_T *sfcnTsMap;

38686
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

38687
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

38688
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

38689
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

38690
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

38691
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

38692
        (void) memset((void*)sfcnPeriod, 0,

38693
                      sizeof(time_T)*1);

38694
        (void) memset((void*)sfcnOffset, 0,

38695
                      sizeof(time_T)*1);

38696
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

38697
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

38698
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

38699


38700
        /* Set up the mdlInfo pointer */

38701
# ifdef USE_RTMODEL

38702


38703
        {

38704
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

38705
              struct _ssBlkInfo2));

38706
          ss_VALIDATE_MEMORY(rts,blkInfo2);

38707
          ssSetBlkInfo2Ptr(childS, blkInfo2);

38708
        }

38709


38710
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

38711


38712
# else

38713


38714
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

38715


38716
# endif                                /* USE_RTMODEL */

38717


38718
        /* Allocate memory of model methods 2 */

38719
        {

38720
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

38721
            malloc(sizeof(struct _ssSFcnModelMethods2));

38722
          ss_VALIDATE_MEMORY(rts,methods2);

38723
          ssSetModelMethods2(childS, methods2);

38724
        }

38725


38726
        /* Allocate memory of model methods 3 */

38727
        {

38728
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

38729
            malloc(sizeof(struct _ssSFcnModelMethods3));

38730
          ss_VALIDATE_MEMORY(rts,methods3);

38731
          ssSetModelMethods3(childS, methods3);

38732
        }

38733


38734
        /* Allocate memory for states auxilliary information */

38735
        {

38736
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

38737
            (sizeof(struct _ssStatesInfo2));

38738
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

38739
            malloc(sizeof(ssPeriodicStatesInfo));

38740
          ss_VALIDATE_MEMORY(rts,statesInfo2);

38741
          ssSetStatesInfo2(childS, statesInfo2);

38742
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

38743
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

38744
        }

38745


38746
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

38747
          RegNumInputPorts);

38748
        ssSetRegNumInputPortsFcnArg(childS,childS);

38749


38750
        /* inputs */

38751
        {

38752
          struct _ssPortInputs *inputPortInfo =

38753
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

38754
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

38755
          _ssSetNumInputPorts(childS, 1);

38756
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

38757


38758
          /* port 0 */

38759
          {

38760
            real32_T const **sfcnUPtrs = (real32_T const **)

38761
              malloc(1 * sizeof(real32_T *));

38762
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38763
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38764
              ssGetLocalBlockIO(rts))->Sum12;

38765
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

38766
            _ssSetInputPortNumDimensions(childS, 0, 1);

38767
            ssSetInputPortWidth(childS, 0, 1);

38768
          }

38769
        }

38770


38771
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

38772
          RegNumOutputPorts);

38773
        ssSetRegNumOutputPortsFcnArg(childS,childS);

38774


38775
        /* outputs */

38776
        {

38777
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

38778
            calloc(1, sizeof(struct _ssPortOutputs));

38779
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

38780
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

38781
          _ssSetNumOutputPorts(childS, 1);

38782


38783
          /* port 0 */

38784
          {

38785
            _ssSetOutputPortNumDimensions(childS, 0, 1);

38786
            ssSetOutputPortWidth(childS, 0, 1);

38787
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

38788
              ssGetLocalBlockIO(rts))->GeneratedSFunction_hl));

38789
          }

38790
        }

38791


38792
        /* path info */

38793
        _ssSetModelName(childS, "NegativePass_sf");

38794
        _ssSetPath(childS,

38795
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim / negative pass1/Generated S-Function");

38796
        if (ssGetRTModel(rts) == (NULL)) {

38797
          _ssSetParentSS(childS, rts);

38798
          _ssSetRootSS(childS, ssGetRootSS(rts));

38799
        } else {

38800
          ssSetRTModel(childS,ssGetRTModel(rts));

38801
          _ssSetParentSS(childS, (NULL));

38802
          _ssSetRootSS(childS, childS);

38803
        }

38804


38805
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

38806
        (childS)->regDataType.arg1 = ((void *)(childS));

38807
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

38808
          FcnSetErrorStatus);

38809
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

38810
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

38811
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

38812
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

38813


38814
        /* registration */

38815
#if defined(MATLAB_MEX_FILE)

38816


38817
        {

38818
          int_T i;

38819
          mxArray *plhs[1];

38820
          mxArray *prhs[4];

38821
          double *pr;

38822
          volatile int_T *intS = (int_T *)&childS;

38823
          int_T addrlen = sizeof(SimStruct *);

38824
          int_T m = addrlen/sizeof(int_T) + 1;

38825
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

38826
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

38827
          pr = mxGetPr(prhs[1]);

38828
          for (i = 0; i < m - 1; i++) {

38829
            pr[i] = (double)intS[i];

38830
          }

38831


38832
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

38833
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

38834
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

38835


38836
          /* Reset port dimensions info functions because the S-function

38837
           * and accelerator mex-files explicitly set their dimensions,

38838
           * i.e., they are not dynamically sized. For this case, the

38839
           * mex-file is responsible for the dimensions info memory

38840
           * and Simulink should not free it. This is achieved by

38841
           * setting the following two methods to NULL.

38842
           */

38843
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

38844
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

38845


38846
          /*

38847
           * Setup function pointers and call mdlInitializeSizes via

38848
           * simulink.c

38849
           */

38850
          mexCallMATLAB(1, plhs, 4, prhs, "NegativePass_sf");

38851
          mxDestroyArray(plhs[0]);

38852
          mxDestroyArray(prhs[0]);

38853
          mxDestroyArray(prhs[1]);

38854
          mxDestroyArray(prhs[2]);

38855
          mxDestroyArray(prhs[3]);

38856
        }

38857


38858
#else

38859


38860
        {

38861
          NegativePass_sf(childS);

38862
          sfcnInitializeSizes(childS);

38863
        }

38864


38865
#endif

38866


38867
        sfcnInitializeSampleTimes(childS);

38868


38869
        /* adjust sample time */

38870
        ssSetSampleTime(childS, 0, 0.0);

38871
        ssSetOffsetTime(childS, 0, 0.0);

38872
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

38873


38874
        /* set compiled values of dynamic vector attributes */

38875
        ssSetNumNonsampledZCs(childS, 0);

38876


38877
        /* Update connectivity flags for each port */

38878
        _ssSetInputPortConnected(childS, 0, 1);

38879
        _ssSetOutputPortConnected(childS, 0, 1);

38880
        _ssSetOutputPortBeingMerged(childS, 0, 0);

38881


38882
        /* Update the BufferDstPort flags for each input port */

38883
        _ssSetInputPortBufferDstPort(childS, 0, -1);

38884
      }

38885


38886
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S270>/Generated S-Function (Gain_sf) */

38887
      {

38888
        SimStruct *childS = ssGetSFunction(rts, 147);

38889


38890
        /* timing info */

38891
        time_T *sfcnPeriod;

38892
        time_T *sfcnOffset;

38893
        int_T *sfcnTsMap;

38894
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

38895
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

38896
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

38897
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

38898
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

38899
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

38900
        (void) memset((void*)sfcnPeriod, 0,

38901
                      sizeof(time_T)*1);

38902
        (void) memset((void*)sfcnOffset, 0,

38903
                      sizeof(time_T)*1);

38904
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

38905
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

38906
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

38907


38908
        /* Set up the mdlInfo pointer */

38909
# ifdef USE_RTMODEL

38910


38911
        {

38912
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

38913
              struct _ssBlkInfo2));

38914
          ss_VALIDATE_MEMORY(rts,blkInfo2);

38915
          ssSetBlkInfo2Ptr(childS, blkInfo2);

38916
        }

38917


38918
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

38919


38920
# else

38921


38922
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

38923


38924
# endif                                /* USE_RTMODEL */

38925


38926
        /* Allocate memory of model methods 2 */

38927
        {

38928
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

38929
            malloc(sizeof(struct _ssSFcnModelMethods2));

38930
          ss_VALIDATE_MEMORY(rts,methods2);

38931
          ssSetModelMethods2(childS, methods2);

38932
        }

38933


38934
        /* Allocate memory of model methods 3 */

38935
        {

38936
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

38937
            malloc(sizeof(struct _ssSFcnModelMethods3));

38938
          ss_VALIDATE_MEMORY(rts,methods3);

38939
          ssSetModelMethods3(childS, methods3);

38940
        }

38941


38942
        /* Allocate memory for states auxilliary information */

38943
        {

38944
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

38945
            (sizeof(struct _ssStatesInfo2));

38946
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

38947
            malloc(sizeof(ssPeriodicStatesInfo));

38948
          ss_VALIDATE_MEMORY(rts,statesInfo2);

38949
          ssSetStatesInfo2(childS, statesInfo2);

38950
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

38951
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

38952
        }

38953


38954
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

38955
          RegNumInputPorts);

38956
        ssSetRegNumInputPortsFcnArg(childS,childS);

38957


38958
        /* inputs */

38959
        {

38960
          struct _ssPortInputs *inputPortInfo =

38961
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

38962
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

38963
          _ssSetNumInputPorts(childS, 2);

38964
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

38965


38966
          /* port 0 */

38967
          {

38968
            real32_T const **sfcnUPtrs = (real32_T const **)

38969
              malloc(1 * sizeof(real32_T *));

38970
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38971
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

38972
              ssGetLocalBlockIO(rts))->GeneratedSFunction_hl;

38973
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

38974
            _ssSetInputPortNumDimensions(childS, 0, 1);

38975
            ssSetInputPortWidth(childS, 0, 1);

38976
          }

38977


38978
          /* port 1 */

38979
          {

38980
            real32_T const **sfcnUPtrs = (real32_T const **)

38981
              malloc(1 * sizeof(real32_T *));

38982
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

38983
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;

38984
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

38985
            _ssSetInputPortNumDimensions(childS, 1, 1);

38986
            ssSetInputPortWidth(childS, 1, 1);

38987
          }

38988
        }

38989


38990
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

38991
          RegNumOutputPorts);

38992
        ssSetRegNumOutputPortsFcnArg(childS,childS);

38993


38994
        /* outputs */

38995
        {

38996
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

38997
            calloc(1, sizeof(struct _ssPortOutputs));

38998
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

38999
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

39000
          _ssSetNumOutputPorts(childS, 1);

39001


39002
          /* port 0 */

39003
          {

39004
            _ssSetOutputPortNumDimensions(childS, 0, 1);

39005
            ssSetOutputPortWidth(childS, 0, 1);

39006
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

39007
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));

39008
          }

39009
        }

39010


39011
        /* path info */

39012
        _ssSetModelName(childS, "Gain_sf");

39013
        _ssSetPath(childS,

39014
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain11/Generated S-Function");

39015
        if (ssGetRTModel(rts) == (NULL)) {

39016
          _ssSetParentSS(childS, rts);

39017
          _ssSetRootSS(childS, ssGetRootSS(rts));

39018
        } else {

39019
          ssSetRTModel(childS,ssGetRTModel(rts));

39020
          _ssSetParentSS(childS, (NULL));

39021
          _ssSetRootSS(childS, childS);

39022
        }

39023


39024
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

39025
        (childS)->regDataType.arg1 = ((void *)(childS));

39026
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

39027
          FcnSetErrorStatus);

39028
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

39029
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

39030
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

39031
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

39032


39033
        /* registration */

39034
#if defined(MATLAB_MEX_FILE)

39035


39036
        {

39037
          int_T i;

39038
          mxArray *plhs[1];

39039
          mxArray *prhs[4];

39040
          double *pr;

39041
          volatile int_T *intS = (int_T *)&childS;

39042
          int_T addrlen = sizeof(SimStruct *);

39043
          int_T m = addrlen/sizeof(int_T) + 1;

39044
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

39045
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

39046
          pr = mxGetPr(prhs[1]);

39047
          for (i = 0; i < m - 1; i++) {

39048
            pr[i] = (double)intS[i];

39049
          }

39050


39051
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

39052
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

39053
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

39054


39055
          /* Reset port dimensions info functions because the S-function

39056
           * and accelerator mex-files explicitly set their dimensions,

39057
           * i.e., they are not dynamically sized. For this case, the

39058
           * mex-file is responsible for the dimensions info memory

39059
           * and Simulink should not free it. This is achieved by

39060
           * setting the following two methods to NULL.

39061
           */

39062
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

39063
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

39064


39065
          /*

39066
           * Setup function pointers and call mdlInitializeSizes via

39067
           * simulink.c

39068
           */

39069
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

39070
          mxDestroyArray(plhs[0]);

39071
          mxDestroyArray(prhs[0]);

39072
          mxDestroyArray(prhs[1]);

39073
          mxDestroyArray(prhs[2]);

39074
          mxDestroyArray(prhs[3]);

39075
        }

39076


39077
#else

39078


39079
        {

39080
          Gain_sf(childS);

39081
          sfcnInitializeSizes(childS);

39082
        }

39083


39084
#endif

39085


39086
        sfcnInitializeSampleTimes(childS);

39087


39088
        /* adjust sample time */

39089
        ssSetSampleTime(childS, 0, 0.0);

39090
        ssSetOffsetTime(childS, 0, 0.0);

39091
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

39092


39093
        /* set compiled values of dynamic vector attributes */

39094
        ssSetNumNonsampledZCs(childS, 0);

39095


39096
        /* Update connectivity flags for each port */

39097
        _ssSetInputPortConnected(childS, 0, 1);

39098
        _ssSetInputPortConnected(childS, 1, 1);

39099
        _ssSetOutputPortConnected(childS, 0, 1);

39100
        _ssSetOutputPortBeingMerged(childS, 0, 0);

39101


39102
        /* Update the BufferDstPort flags for each input port */

39103
        _ssSetInputPortBufferDstPort(childS, 0, -1);

39104
        _ssSetInputPortBufferDstPort(childS, 1, -1);

39105
      }

39106


39107
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S272>/Generated S-Function (PositivePass_sf) */

39108
      {

39109
        SimStruct *childS = ssGetSFunction(rts, 148);

39110


39111
        /* timing info */

39112
        time_T *sfcnPeriod;

39113
        time_T *sfcnOffset;

39114
        int_T *sfcnTsMap;

39115
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

39116
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

39117
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

39118
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

39119
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

39120
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

39121
        (void) memset((void*)sfcnPeriod, 0,

39122
                      sizeof(time_T)*1);

39123
        (void) memset((void*)sfcnOffset, 0,

39124
                      sizeof(time_T)*1);

39125
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

39126
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

39127
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

39128


39129
        /* Set up the mdlInfo pointer */

39130
# ifdef USE_RTMODEL

39131


39132
        {

39133
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

39134
              struct _ssBlkInfo2));

39135
          ss_VALIDATE_MEMORY(rts,blkInfo2);

39136
          ssSetBlkInfo2Ptr(childS, blkInfo2);

39137
        }

39138


39139
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

39140


39141
# else

39142


39143
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

39144


39145
# endif                                /* USE_RTMODEL */

39146


39147
        /* Allocate memory of model methods 2 */

39148
        {

39149
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

39150
            malloc(sizeof(struct _ssSFcnModelMethods2));

39151
          ss_VALIDATE_MEMORY(rts,methods2);

39152
          ssSetModelMethods2(childS, methods2);

39153
        }

39154


39155
        /* Allocate memory of model methods 3 */

39156
        {

39157
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

39158
            malloc(sizeof(struct _ssSFcnModelMethods3));

39159
          ss_VALIDATE_MEMORY(rts,methods3);

39160
          ssSetModelMethods3(childS, methods3);

39161
        }

39162


39163
        /* Allocate memory for states auxilliary information */

39164
        {

39165
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

39166
            (sizeof(struct _ssStatesInfo2));

39167
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

39168
            malloc(sizeof(ssPeriodicStatesInfo));

39169
          ss_VALIDATE_MEMORY(rts,statesInfo2);

39170
          ssSetStatesInfo2(childS, statesInfo2);

39171
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

39172
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

39173
        }

39174


39175
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

39176
          RegNumInputPorts);

39177
        ssSetRegNumInputPortsFcnArg(childS,childS);

39178


39179
        /* inputs */

39180
        {

39181
          struct _ssPortInputs *inputPortInfo =

39182
            (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));

39183
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

39184
          _ssSetNumInputPorts(childS, 1);

39185
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

39186


39187
          /* port 0 */

39188
          {

39189
            real32_T const **sfcnUPtrs = (real32_T const **)

39190
              malloc(1 * sizeof(real32_T *));

39191
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

39192
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

39193
              ssGetLocalBlockIO(rts))->Sum2_n;

39194
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

39195
            _ssSetInputPortNumDimensions(childS, 0, 1);

39196
            ssSetInputPortWidth(childS, 0, 1);

39197
          }

39198
        }

39199


39200
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

39201
          RegNumOutputPorts);

39202
        ssSetRegNumOutputPortsFcnArg(childS,childS);

39203


39204
        /* outputs */

39205
        {

39206
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

39207
            calloc(1, sizeof(struct _ssPortOutputs));

39208
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

39209
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

39210
          _ssSetNumOutputPorts(childS, 1);

39211


39212
          /* port 0 */

39213
          {

39214
            _ssSetOutputPortNumDimensions(childS, 0, 1);

39215
            ssSetOutputPortWidth(childS, 0, 1);

39216
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

39217
              ssGetLocalBlockIO(rts))->GeneratedSFunction_m5));

39218
          }

39219
        }

39220


39221
        /* path info */

39222
        _ssSetModelName(childS, "PositivePass_sf");

39223
        _ssSetPath(childS,

39224
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /positive pass1/Generated S-Function");

39225
        if (ssGetRTModel(rts) == (NULL)) {

39226
          _ssSetParentSS(childS, rts);

39227
          _ssSetRootSS(childS, ssGetRootSS(rts));

39228
        } else {

39229
          ssSetRTModel(childS,ssGetRTModel(rts));

39230
          _ssSetParentSS(childS, (NULL));

39231
          _ssSetRootSS(childS, childS);

39232
        }

39233


39234
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

39235
        (childS)->regDataType.arg1 = ((void *)(childS));

39236
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

39237
          FcnSetErrorStatus);

39238
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

39239
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

39240
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

39241
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

39242


39243
        /* registration */

39244
#if defined(MATLAB_MEX_FILE)

39245


39246
        {

39247
          int_T i;

39248
          mxArray *plhs[1];

39249
          mxArray *prhs[4];

39250
          double *pr;

39251
          volatile int_T *intS = (int_T *)&childS;

39252
          int_T addrlen = sizeof(SimStruct *);

39253
          int_T m = addrlen/sizeof(int_T) + 1;

39254
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

39255
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

39256
          pr = mxGetPr(prhs[1]);

39257
          for (i = 0; i < m - 1; i++) {

39258
            pr[i] = (double)intS[i];

39259
          }

39260


39261
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

39262
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

39263
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

39264


39265
          /* Reset port dimensions info functions because the S-function

39266
           * and accelerator mex-files explicitly set their dimensions,

39267
           * i.e., they are not dynamically sized. For this case, the

39268
           * mex-file is responsible for the dimensions info memory

39269
           * and Simulink should not free it. This is achieved by

39270
           * setting the following two methods to NULL.

39271
           */

39272
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

39273
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

39274


39275
          /*

39276
           * Setup function pointers and call mdlInitializeSizes via

39277
           * simulink.c

39278
           */

39279
          mexCallMATLAB(1, plhs, 4, prhs, "PositivePass_sf");

39280
          mxDestroyArray(plhs[0]);

39281
          mxDestroyArray(prhs[0]);

39282
          mxDestroyArray(prhs[1]);

39283
          mxDestroyArray(prhs[2]);

39284
          mxDestroyArray(prhs[3]);

39285
        }

39286


39287
#else

39288


39289
        {

39290
          PositivePass_sf(childS);

39291
          sfcnInitializeSizes(childS);

39292
        }

39293


39294
#endif

39295


39296
        sfcnInitializeSampleTimes(childS);

39297


39298
        /* adjust sample time */

39299
        ssSetSampleTime(childS, 0, 0.0);

39300
        ssSetOffsetTime(childS, 0, 0.0);

39301
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

39302


39303
        /* set compiled values of dynamic vector attributes */

39304
        ssSetNumNonsampledZCs(childS, 0);

39305


39306
        /* Update connectivity flags for each port */

39307
        _ssSetInputPortConnected(childS, 0, 1);

39308
        _ssSetOutputPortConnected(childS, 0, 1);

39309
        _ssSetOutputPortBeingMerged(childS, 0, 0);

39310


39311
        /* Update the BufferDstPort flags for each input port */

39312
        _ssSetInputPortBufferDstPort(childS, 0, -1);

39313
      }

39314


39315
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S271>/Generated S-Function (Gain_sf) */

39316
      {

39317
        SimStruct *childS = ssGetSFunction(rts, 149);

39318


39319
        /* timing info */

39320
        time_T *sfcnPeriod;

39321
        time_T *sfcnOffset;

39322
        int_T *sfcnTsMap;

39323
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

39324
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

39325
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

39326
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

39327
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

39328
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

39329
        (void) memset((void*)sfcnPeriod, 0,

39330
                      sizeof(time_T)*1);

39331
        (void) memset((void*)sfcnOffset, 0,

39332
                      sizeof(time_T)*1);

39333
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

39334
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

39335
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

39336


39337
        /* Set up the mdlInfo pointer */

39338
# ifdef USE_RTMODEL

39339


39340
        {

39341
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

39342
              struct _ssBlkInfo2));

39343
          ss_VALIDATE_MEMORY(rts,blkInfo2);

39344
          ssSetBlkInfo2Ptr(childS, blkInfo2);

39345
        }

39346


39347
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

39348


39349
# else

39350


39351
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

39352


39353
# endif                                /* USE_RTMODEL */

39354


39355
        /* Allocate memory of model methods 2 */

39356
        {

39357
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

39358
            malloc(sizeof(struct _ssSFcnModelMethods2));

39359
          ss_VALIDATE_MEMORY(rts,methods2);

39360
          ssSetModelMethods2(childS, methods2);

39361
        }

39362


39363
        /* Allocate memory of model methods 3 */

39364
        {

39365
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

39366
            malloc(sizeof(struct _ssSFcnModelMethods3));

39367
          ss_VALIDATE_MEMORY(rts,methods3);

39368
          ssSetModelMethods3(childS, methods3);

39369
        }

39370


39371
        /* Allocate memory for states auxilliary information */

39372
        {

39373
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

39374
            (sizeof(struct _ssStatesInfo2));

39375
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

39376
            malloc(sizeof(ssPeriodicStatesInfo));

39377
          ss_VALIDATE_MEMORY(rts,statesInfo2);

39378
          ssSetStatesInfo2(childS, statesInfo2);

39379
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

39380
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

39381
        }

39382


39383
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

39384
          RegNumInputPorts);

39385
        ssSetRegNumInputPortsFcnArg(childS,childS);

39386


39387
        /* inputs */

39388
        {

39389
          struct _ssPortInputs *inputPortInfo =

39390
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

39391
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

39392
          _ssSetNumInputPorts(childS, 2);

39393
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

39394


39395
          /* port 0 */

39396
          {

39397
            real32_T const **sfcnUPtrs = (real32_T const **)

39398
              malloc(1 * sizeof(real32_T *));

39399
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

39400
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

39401
              ssGetLocalBlockIO(rts))->GeneratedSFunction_m5;

39402
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

39403
            _ssSetInputPortNumDimensions(childS, 0, 1);

39404
            ssSetInputPortWidth(childS, 0, 1);

39405
          }

39406


39407
          /* port 1 */

39408
          {

39409
            real32_T const **sfcnUPtrs = (real32_T const **)

39410
              malloc(1 * sizeof(real32_T *));

39411
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

39412
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;

39413
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

39414
            _ssSetInputPortNumDimensions(childS, 1, 1);

39415
            ssSetInputPortWidth(childS, 1, 1);

39416
          }

39417
        }

39418


39419
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

39420
          RegNumOutputPorts);

39421
        ssSetRegNumOutputPortsFcnArg(childS,childS);

39422


39423
        /* outputs */

39424
        {

39425
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

39426
            calloc(1, sizeof(struct _ssPortOutputs));

39427
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

39428
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

39429
          _ssSetNumOutputPorts(childS, 1);

39430


39431
          /* port 0 */

39432
          {

39433
            _ssSetOutputPortNumDimensions(childS, 0, 1);

39434
            ssSetOutputPortWidth(childS, 0, 1);

39435
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

39436
              ssGetLocalBlockIO(rts))->MinMax));

39437
          }

39438
        }

39439


39440
        /* path info */

39441
        _ssSetModelName(childS, "Gain_sf");

39442
        _ssSetPath(childS,

39443
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain9/Generated S-Function");

39444
        if (ssGetRTModel(rts) == (NULL)) {

39445
          _ssSetParentSS(childS, rts);

39446
          _ssSetRootSS(childS, ssGetRootSS(rts));

39447
        } else {

39448
          ssSetRTModel(childS,ssGetRTModel(rts));

39449
          _ssSetParentSS(childS, (NULL));

39450
          _ssSetRootSS(childS, childS);

39451
        }

39452


39453
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

39454
        (childS)->regDataType.arg1 = ((void *)(childS));

39455
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

39456
          FcnSetErrorStatus);

39457
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

39458
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

39459
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

39460
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

39461


39462
        /* registration */

39463
#if defined(MATLAB_MEX_FILE)

39464


39465
        {

39466
          int_T i;

39467
          mxArray *plhs[1];

39468
          mxArray *prhs[4];

39469
          double *pr;

39470
          volatile int_T *intS = (int_T *)&childS;

39471
          int_T addrlen = sizeof(SimStruct *);

39472
          int_T m = addrlen/sizeof(int_T) + 1;

39473
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

39474
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

39475
          pr = mxGetPr(prhs[1]);

39476
          for (i = 0; i < m - 1; i++) {

39477
            pr[i] = (double)intS[i];

39478
          }

39479


39480
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

39481
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

39482
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

39483


39484
          /* Reset port dimensions info functions because the S-function

39485
           * and accelerator mex-files explicitly set their dimensions,

39486
           * i.e., they are not dynamically sized. For this case, the

39487
           * mex-file is responsible for the dimensions info memory

39488
           * and Simulink should not free it. This is achieved by

39489
           * setting the following two methods to NULL.

39490
           */

39491
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

39492
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

39493


39494
          /*

39495
           * Setup function pointers and call mdlInitializeSizes via

39496
           * simulink.c

39497
           */

39498
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

39499
          mxDestroyArray(plhs[0]);

39500
          mxDestroyArray(prhs[0]);

39501
          mxDestroyArray(prhs[1]);

39502
          mxDestroyArray(prhs[2]);

39503
          mxDestroyArray(prhs[3]);

39504
        }

39505


39506
#else

39507


39508
        {

39509
          Gain_sf(childS);

39510
          sfcnInitializeSizes(childS);

39511
        }

39512


39513
#endif

39514


39515
        sfcnInitializeSampleTimes(childS);

39516


39517
        /* adjust sample time */

39518
        ssSetSampleTime(childS, 0, 0.0);

39519
        ssSetOffsetTime(childS, 0, 0.0);

39520
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

39521


39522
        /* set compiled values of dynamic vector attributes */

39523
        ssSetNumNonsampledZCs(childS, 0);

39524


39525
        /* Update connectivity flags for each port */

39526
        _ssSetInputPortConnected(childS, 0, 1);

39527
        _ssSetInputPortConnected(childS, 1, 1);

39528
        _ssSetOutputPortConnected(childS, 0, 1);

39529
        _ssSetOutputPortBeingMerged(childS, 0, 0);

39530


39531
        /* Update the BufferDstPort flags for each input port */

39532
        _ssSetInputPortBufferDstPort(childS, 0, -1);

39533
        _ssSetInputPortBufferDstPort(childS, 1, -1);

39534
      }

39535


39536
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S261>/Generated S-Function (Gain_sf) */

39537
      {

39538
        SimStruct *childS = ssGetSFunction(rts, 150);

39539


39540
        /* timing info */

39541
        time_T *sfcnPeriod;

39542
        time_T *sfcnOffset;

39543
        int_T *sfcnTsMap;

39544
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

39545
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

39546
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

39547
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

39548
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

39549
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

39550
        (void) memset((void*)sfcnPeriod, 0,

39551
                      sizeof(time_T)*1);

39552
        (void) memset((void*)sfcnOffset, 0,

39553
                      sizeof(time_T)*1);

39554
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

39555
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

39556
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

39557


39558
        /* Set up the mdlInfo pointer */

39559
# ifdef USE_RTMODEL

39560


39561
        {

39562
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

39563
              struct _ssBlkInfo2));

39564
          ss_VALIDATE_MEMORY(rts,blkInfo2);

39565
          ssSetBlkInfo2Ptr(childS, blkInfo2);

39566
        }

39567


39568
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

39569


39570
# else

39571


39572
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

39573


39574
# endif                                /* USE_RTMODEL */

39575


39576
        /* Allocate memory of model methods 2 */

39577
        {

39578
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

39579
            malloc(sizeof(struct _ssSFcnModelMethods2));

39580
          ss_VALIDATE_MEMORY(rts,methods2);

39581
          ssSetModelMethods2(childS, methods2);

39582
        }

39583


39584
        /* Allocate memory of model methods 3 */

39585
        {

39586
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

39587
            malloc(sizeof(struct _ssSFcnModelMethods3));

39588
          ss_VALIDATE_MEMORY(rts,methods3);

39589
          ssSetModelMethods3(childS, methods3);

39590
        }

39591


39592
        /* Allocate memory for states auxilliary information */

39593
        {

39594
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

39595
            (sizeof(struct _ssStatesInfo2));

39596
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

39597
            malloc(sizeof(ssPeriodicStatesInfo));

39598
          ss_VALIDATE_MEMORY(rts,statesInfo2);

39599
          ssSetStatesInfo2(childS, statesInfo2);

39600
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

39601
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

39602
        }

39603


39604
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

39605
          RegNumInputPorts);

39606
        ssSetRegNumInputPortsFcnArg(childS,childS);

39607


39608
        /* inputs */

39609
        {

39610
          struct _ssPortInputs *inputPortInfo =

39611
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

39612
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

39613
          _ssSetNumInputPorts(childS, 2);

39614
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

39615


39616
          /* port 0 */

39617
          {

39618
            real32_T const **sfcnUPtrs = (real32_T const **)

39619
              malloc(1 * sizeof(real32_T *));

39620
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

39621
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

39622
              ssGetLocalBlockIO(rts))->GeneratedSFunction8_p;

39623
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

39624
            _ssSetInputPortNumDimensions(childS, 0, 1);

39625
            ssSetInputPortWidth(childS, 0, 1);

39626
          }

39627


39628
          /* port 1 */

39629
          {

39630
            real32_T const **sfcnUPtrs = (real32_T const **)

39631
              malloc(1 * sizeof(real32_T *));

39632
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

39633
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

39634
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

39635
            _ssSetInputPortNumDimensions(childS, 1, 1);

39636
            ssSetInputPortWidth(childS, 1, 1);

39637
          }

39638
        }

39639


39640
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

39641
          RegNumOutputPorts);

39642
        ssSetRegNumOutputPortsFcnArg(childS,childS);

39643


39644
        /* outputs */

39645
        {

39646
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

39647
            calloc(1, sizeof(struct _ssPortOutputs));

39648
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

39649
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

39650
          _ssSetNumOutputPorts(childS, 1);

39651


39652
          /* port 0 */

39653
          {

39654
            _ssSetOutputPortNumDimensions(childS, 0, 1);

39655
            ssSetOutputPortWidth(childS, 0, 1);

39656
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

39657
              ssGetLocalBlockIO(rts))->Saturation9));

39658
          }

39659
        }

39660


39661
        /* path info */

39662
        _ssSetModelName(childS, "Gain_sf");

39663
        _ssSetPath(childS,

39664
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain2/Generated S-Function");

39665
        if (ssGetRTModel(rts) == (NULL)) {

39666
          _ssSetParentSS(childS, rts);

39667
          _ssSetRootSS(childS, ssGetRootSS(rts));

39668
        } else {

39669
          ssSetRTModel(childS,ssGetRTModel(rts));

39670
          _ssSetParentSS(childS, (NULL));

39671
          _ssSetRootSS(childS, childS);

39672
        }

39673


39674
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

39675
        (childS)->regDataType.arg1 = ((void *)(childS));

39676
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

39677
          FcnSetErrorStatus);

39678
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

39679
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

39680
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

39681
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

39682


39683
        /* registration */

39684
#if defined(MATLAB_MEX_FILE)

39685


39686
        {

39687
          int_T i;

39688
          mxArray *plhs[1];

39689
          mxArray *prhs[4];

39690
          double *pr;

39691
          volatile int_T *intS = (int_T *)&childS;

39692
          int_T addrlen = sizeof(SimStruct *);

39693
          int_T m = addrlen/sizeof(int_T) + 1;

39694
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

39695
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

39696
          pr = mxGetPr(prhs[1]);

39697
          for (i = 0; i < m - 1; i++) {

39698
            pr[i] = (double)intS[i];

39699
          }

39700


39701
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

39702
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

39703
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

39704


39705
          /* Reset port dimensions info functions because the S-function

39706
           * and accelerator mex-files explicitly set their dimensions,

39707
           * i.e., they are not dynamically sized. For this case, the

39708
           * mex-file is responsible for the dimensions info memory

39709
           * and Simulink should not free it. This is achieved by

39710
           * setting the following two methods to NULL.

39711
           */

39712
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

39713
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

39714


39715
          /*

39716
           * Setup function pointers and call mdlInitializeSizes via

39717
           * simulink.c

39718
           */

39719
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

39720
          mxDestroyArray(plhs[0]);

39721
          mxDestroyArray(prhs[0]);

39722
          mxDestroyArray(prhs[1]);

39723
          mxDestroyArray(prhs[2]);

39724
          mxDestroyArray(prhs[3]);

39725
        }

39726


39727
#else

39728


39729
        {

39730
          Gain_sf(childS);

39731
          sfcnInitializeSizes(childS);

39732
        }

39733


39734
#endif

39735


39736
        sfcnInitializeSampleTimes(childS);

39737


39738
        /* adjust sample time */

39739
        ssSetSampleTime(childS, 0, 0.0);

39740
        ssSetOffsetTime(childS, 0, 0.0);

39741
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

39742


39743
        /* set compiled values of dynamic vector attributes */

39744
        ssSetNumNonsampledZCs(childS, 0);

39745


39746
        /* Update connectivity flags for each port */

39747
        _ssSetInputPortConnected(childS, 0, 1);

39748
        _ssSetInputPortConnected(childS, 1, 1);

39749
        _ssSetOutputPortConnected(childS, 0, 1);

39750
        _ssSetOutputPortBeingMerged(childS, 0, 0);

39751


39752
        /* Update the BufferDstPort flags for each input port */

39753
        _ssSetInputPortBufferDstPort(childS, 0, -1);

39754
        _ssSetInputPortBufferDstPort(childS, 1, -1);

39755
      }

39756


39757
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S262>/Generated S-Function (Gain_sf) */

39758
      {

39759
        SimStruct *childS = ssGetSFunction(rts, 151);

39760


39761
        /* timing info */

39762
        time_T *sfcnPeriod;

39763
        time_T *sfcnOffset;

39764
        int_T *sfcnTsMap;

39765
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

39766
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

39767
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

39768
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

39769
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

39770
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

39771
        (void) memset((void*)sfcnPeriod, 0,

39772
                      sizeof(time_T)*1);

39773
        (void) memset((void*)sfcnOffset, 0,

39774
                      sizeof(time_T)*1);

39775
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

39776
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

39777
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

39778


39779
        /* Set up the mdlInfo pointer */

39780
# ifdef USE_RTMODEL

39781


39782
        {

39783
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

39784
              struct _ssBlkInfo2));

39785
          ss_VALIDATE_MEMORY(rts,blkInfo2);

39786
          ssSetBlkInfo2Ptr(childS, blkInfo2);

39787
        }

39788


39789
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

39790


39791
# else

39792


39793
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

39794


39795
# endif                                /* USE_RTMODEL */

39796


39797
        /* Allocate memory of model methods 2 */

39798
        {

39799
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

39800
            malloc(sizeof(struct _ssSFcnModelMethods2));

39801
          ss_VALIDATE_MEMORY(rts,methods2);

39802
          ssSetModelMethods2(childS, methods2);

39803
        }

39804


39805
        /* Allocate memory of model methods 3 */

39806
        {

39807
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

39808
            malloc(sizeof(struct _ssSFcnModelMethods3));

39809
          ss_VALIDATE_MEMORY(rts,methods3);

39810
          ssSetModelMethods3(childS, methods3);

39811
        }

39812


39813
        /* Allocate memory for states auxilliary information */

39814
        {

39815
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

39816
            (sizeof(struct _ssStatesInfo2));

39817
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

39818
            malloc(sizeof(ssPeriodicStatesInfo));

39819
          ss_VALIDATE_MEMORY(rts,statesInfo2);

39820
          ssSetStatesInfo2(childS, statesInfo2);

39821
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

39822
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

39823
        }

39824


39825
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

39826
          RegNumInputPorts);

39827
        ssSetRegNumInputPortsFcnArg(childS,childS);

39828


39829
        /* inputs */

39830
        {

39831
          struct _ssPortInputs *inputPortInfo =

39832
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

39833
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

39834
          _ssSetNumInputPorts(childS, 2);

39835
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

39836


39837
          /* port 0 */

39838
          {

39839
            real32_T const **sfcnUPtrs = (real32_T const **)

39840
              malloc(1 * sizeof(real32_T *));

39841
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

39842
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

39843
              ssGetLocalBlockIO(rts))->Sum6_j;

39844
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

39845
            _ssSetInputPortNumDimensions(childS, 0, 1);

39846
            ssSetInputPortWidth(childS, 0, 1);

39847
          }

39848


39849
          /* port 1 */

39850
          {

39851
            real32_T const **sfcnUPtrs = (real32_T const **)

39852
              malloc(1 * sizeof(real32_T *));

39853
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

39854
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

39855
              ssGetLocalBlockIO(rts))->Product1_j;

39856
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

39857
            _ssSetInputPortNumDimensions(childS, 1, 1);

39858
            ssSetInputPortWidth(childS, 1, 1);

39859
          }

39860
        }

39861


39862
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

39863
          RegNumOutputPorts);

39864
        ssSetRegNumOutputPortsFcnArg(childS,childS);

39865


39866
        /* outputs */

39867
        {

39868
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

39869
            calloc(1, sizeof(struct _ssPortOutputs));

39870
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

39871
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

39872
          _ssSetNumOutputPorts(childS, 1);

39873


39874
          /* port 0 */

39875
          {

39876
            _ssSetOutputPortNumDimensions(childS, 0, 1);

39877
            ssSetOutputPortWidth(childS, 0, 1);

39878
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

39879
              ssGetLocalBlockIO(rts))->GeneratedSFunction_l));

39880
          }

39881
        }

39882


39883
        /* path info */

39884
        _ssSetModelName(childS, "Gain_sf");

39885
        _ssSetPath(childS,

39886
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain3/Generated S-Function");

39887
        if (ssGetRTModel(rts) == (NULL)) {

39888
          _ssSetParentSS(childS, rts);

39889
          _ssSetRootSS(childS, ssGetRootSS(rts));

39890
        } else {

39891
          ssSetRTModel(childS,ssGetRTModel(rts));

39892
          _ssSetParentSS(childS, (NULL));

39893
          _ssSetRootSS(childS, childS);

39894
        }

39895


39896
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

39897
        (childS)->regDataType.arg1 = ((void *)(childS));

39898
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

39899
          FcnSetErrorStatus);

39900
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

39901
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

39902
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

39903
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

39904


39905
        /* registration */

39906
#if defined(MATLAB_MEX_FILE)

39907


39908
        {

39909
          int_T i;

39910
          mxArray *plhs[1];

39911
          mxArray *prhs[4];

39912
          double *pr;

39913
          volatile int_T *intS = (int_T *)&childS;

39914
          int_T addrlen = sizeof(SimStruct *);

39915
          int_T m = addrlen/sizeof(int_T) + 1;

39916
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

39917
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

39918
          pr = mxGetPr(prhs[1]);

39919
          for (i = 0; i < m - 1; i++) {

39920
            pr[i] = (double)intS[i];

39921
          }

39922


39923
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

39924
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

39925
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

39926


39927
          /* Reset port dimensions info functions because the S-function

39928
           * and accelerator mex-files explicitly set their dimensions,

39929
           * i.e., they are not dynamically sized. For this case, the

39930
           * mex-file is responsible for the dimensions info memory

39931
           * and Simulink should not free it. This is achieved by

39932
           * setting the following two methods to NULL.

39933
           */

39934
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

39935
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

39936


39937
          /*

39938
           * Setup function pointers and call mdlInitializeSizes via

39939
           * simulink.c

39940
           */

39941
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

39942
          mxDestroyArray(plhs[0]);

39943
          mxDestroyArray(prhs[0]);

39944
          mxDestroyArray(prhs[1]);

39945
          mxDestroyArray(prhs[2]);

39946
          mxDestroyArray(prhs[3]);

39947
        }

39948


39949
#else

39950


39951
        {

39952
          Gain_sf(childS);

39953
          sfcnInitializeSizes(childS);

39954
        }

39955


39956
#endif

39957


39958
        sfcnInitializeSampleTimes(childS);

39959


39960
        /* adjust sample time */

39961
        ssSetSampleTime(childS, 0, 0.0);

39962
        ssSetOffsetTime(childS, 0, 0.0);

39963
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

39964


39965
        /* set compiled values of dynamic vector attributes */

39966
        ssSetNumNonsampledZCs(childS, 0);

39967


39968
        /* Update connectivity flags for each port */

39969
        _ssSetInputPortConnected(childS, 0, 1);

39970
        _ssSetInputPortConnected(childS, 1, 1);

39971
        _ssSetOutputPortConnected(childS, 0, 1);

39972
        _ssSetOutputPortBeingMerged(childS, 0, 0);

39973


39974
        /* Update the BufferDstPort flags for each input port */

39975
        _ssSetInputPortBufferDstPort(childS, 0, -1);

39976
        _ssSetInputPortBufferDstPort(childS, 1, -1);

39977
      }

39978


39979
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S258>/Generated S-Function1 (SaturationLimiter_sf) */

39980
      {

39981
        SimStruct *childS = ssGetSFunction(rts, 152);

39982


39983
        /* timing info */

39984
        time_T *sfcnPeriod;

39985
        time_T *sfcnOffset;

39986
        int_T *sfcnTsMap;

39987
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

39988
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

39989
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

39990
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

39991
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

39992
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

39993
        (void) memset((void*)sfcnPeriod, 0,

39994
                      sizeof(time_T)*1);

39995
        (void) memset((void*)sfcnOffset, 0,

39996
                      sizeof(time_T)*1);

39997
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

39998
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

39999
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

40000


40001
        /* Set up the mdlInfo pointer */

40002
# ifdef USE_RTMODEL

40003


40004
        {

40005
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

40006
              struct _ssBlkInfo2));

40007
          ss_VALIDATE_MEMORY(rts,blkInfo2);

40008
          ssSetBlkInfo2Ptr(childS, blkInfo2);

40009
        }

40010


40011
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

40012


40013
# else

40014


40015
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

40016


40017
# endif                                /* USE_RTMODEL */

40018


40019
        /* Allocate memory of model methods 2 */

40020
        {

40021
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

40022
            malloc(sizeof(struct _ssSFcnModelMethods2));

40023
          ss_VALIDATE_MEMORY(rts,methods2);

40024
          ssSetModelMethods2(childS, methods2);

40025
        }

40026


40027
        /* Allocate memory of model methods 3 */

40028
        {

40029
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

40030
            malloc(sizeof(struct _ssSFcnModelMethods3));

40031
          ss_VALIDATE_MEMORY(rts,methods3);

40032
          ssSetModelMethods3(childS, methods3);

40033
        }

40034


40035
        /* Allocate memory for states auxilliary information */

40036
        {

40037
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

40038
            (sizeof(struct _ssStatesInfo2));

40039
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

40040
            malloc(sizeof(ssPeriodicStatesInfo));

40041
          ss_VALIDATE_MEMORY(rts,statesInfo2);

40042
          ssSetStatesInfo2(childS, statesInfo2);

40043
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

40044
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

40045
        }

40046


40047
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

40048
          RegNumInputPorts);

40049
        ssSetRegNumInputPortsFcnArg(childS,childS);

40050


40051
        /* inputs */

40052
        {

40053
          struct _ssPortInputs *inputPortInfo =

40054
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

40055
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

40056
          _ssSetNumInputPorts(childS, 3);

40057
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

40058


40059
          /* port 0 */

40060
          {

40061
            real32_T const **sfcnUPtrs = (real32_T const **)

40062
              malloc(1 * sizeof(real32_T *));

40063
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40064
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40065
              ssGetLocalBlockIO(rts))->GeneratedSFunction_l;

40066
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

40067
            _ssSetInputPortNumDimensions(childS, 0, 1);

40068
            ssSetInputPortWidth(childS, 0, 1);

40069
          }

40070


40071
          /* port 1 */

40072
          {

40073
            real32_T const **sfcnUPtrs = (real32_T const **)

40074
              malloc(1 * sizeof(real32_T *));

40075
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40076
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;

40077
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

40078
            _ssSetInputPortNumDimensions(childS, 1, 1);

40079
            ssSetInputPortWidth(childS, 1, 1);

40080
          }

40081


40082
          /* port 2 */

40083
          {

40084
            real32_T const **sfcnUPtrs = (real32_T const **)

40085
              malloc(1 * sizeof(real32_T *));

40086
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40087
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;

40088
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

40089
            _ssSetInputPortNumDimensions(childS, 2, 1);

40090
            ssSetInputPortWidth(childS, 2, 1);

40091
          }

40092
        }

40093


40094
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

40095
          RegNumOutputPorts);

40096
        ssSetRegNumOutputPortsFcnArg(childS,childS);

40097


40098
        /* outputs */

40099
        {

40100
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

40101
            calloc(1, sizeof(struct _ssPortOutputs));

40102
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

40103
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

40104
          _ssSetNumOutputPorts(childS, 1);

40105


40106
          /* port 0 */

40107
          {

40108
            _ssSetOutputPortNumDimensions(childS, 0, 1);

40109
            ssSetOutputPortWidth(childS, 0, 1);

40110
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

40111
              ssGetLocalBlockIO(rts))->Saturation9));

40112
          }

40113
        }

40114


40115
        /* path info */

40116
        _ssSetModelName(childS, "SaturationLimiter_sf");

40117
        _ssSetPath(childS,

40118
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/Saturation Limiter1/Generated S-Function1");

40119
        if (ssGetRTModel(rts) == (NULL)) {

40120
          _ssSetParentSS(childS, rts);

40121
          _ssSetRootSS(childS, ssGetRootSS(rts));

40122
        } else {

40123
          ssSetRTModel(childS,ssGetRTModel(rts));

40124
          _ssSetParentSS(childS, (NULL));

40125
          _ssSetRootSS(childS, childS);

40126
        }

40127


40128
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

40129
        (childS)->regDataType.arg1 = ((void *)(childS));

40130
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

40131
          FcnSetErrorStatus);

40132
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

40133
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

40134
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

40135
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

40136


40137
        /* registration */

40138
#if defined(MATLAB_MEX_FILE)

40139


40140
        {

40141
          int_T i;

40142
          mxArray *plhs[1];

40143
          mxArray *prhs[4];

40144
          double *pr;

40145
          volatile int_T *intS = (int_T *)&childS;

40146
          int_T addrlen = sizeof(SimStruct *);

40147
          int_T m = addrlen/sizeof(int_T) + 1;

40148
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

40149
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

40150
          pr = mxGetPr(prhs[1]);

40151
          for (i = 0; i < m - 1; i++) {

40152
            pr[i] = (double)intS[i];

40153
          }

40154


40155
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

40156
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

40157
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

40158


40159
          /* Reset port dimensions info functions because the S-function

40160
           * and accelerator mex-files explicitly set their dimensions,

40161
           * i.e., they are not dynamically sized. For this case, the

40162
           * mex-file is responsible for the dimensions info memory

40163
           * and Simulink should not free it. This is achieved by

40164
           * setting the following two methods to NULL.

40165
           */

40166
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

40167
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

40168


40169
          /*

40170
           * Setup function pointers and call mdlInitializeSizes via

40171
           * simulink.c

40172
           */

40173
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

40174
          mxDestroyArray(plhs[0]);

40175
          mxDestroyArray(prhs[0]);

40176
          mxDestroyArray(prhs[1]);

40177
          mxDestroyArray(prhs[2]);

40178
          mxDestroyArray(prhs[3]);

40179
        }

40180


40181
#else

40182


40183
        {

40184
          SaturationLimiter_sf(childS);

40185
          sfcnInitializeSizes(childS);

40186
        }

40187


40188
#endif

40189


40190
        sfcnInitializeSampleTimes(childS);

40191


40192
        /* adjust sample time */

40193
        ssSetSampleTime(childS, 0, 0.0);

40194
        ssSetOffsetTime(childS, 0, 0.0);

40195
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

40196


40197
        /* set compiled values of dynamic vector attributes */

40198
        ssSetNumNonsampledZCs(childS, 0);

40199


40200
        /* Update connectivity flags for each port */

40201
        _ssSetInputPortConnected(childS, 0, 1);

40202
        _ssSetInputPortConnected(childS, 1, 1);

40203
        _ssSetInputPortConnected(childS, 2, 1);

40204
        _ssSetOutputPortConnected(childS, 0, 1);

40205
        _ssSetOutputPortBeingMerged(childS, 0, 0);

40206


40207
        /* Update the BufferDstPort flags for each input port */

40208
        _ssSetInputPortBufferDstPort(childS, 0, -1);

40209
        _ssSetInputPortBufferDstPort(childS, 1, -1);

40210
        _ssSetInputPortBufferDstPort(childS, 2, -1);

40211
      }

40212


40213
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S263>/Generated S-Function (Gain_sf) */

40214
      {

40215
        SimStruct *childS = ssGetSFunction(rts, 153);

40216


40217
        /* timing info */

40218
        time_T *sfcnPeriod;

40219
        time_T *sfcnOffset;

40220
        int_T *sfcnTsMap;

40221
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

40222
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

40223
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

40224
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

40225
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

40226
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

40227
        (void) memset((void*)sfcnPeriod, 0,

40228
                      sizeof(time_T)*1);

40229
        (void) memset((void*)sfcnOffset, 0,

40230
                      sizeof(time_T)*1);

40231
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

40232
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

40233
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

40234


40235
        /* Set up the mdlInfo pointer */

40236
# ifdef USE_RTMODEL

40237


40238
        {

40239
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

40240
              struct _ssBlkInfo2));

40241
          ss_VALIDATE_MEMORY(rts,blkInfo2);

40242
          ssSetBlkInfo2Ptr(childS, blkInfo2);

40243
        }

40244


40245
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

40246


40247
# else

40248


40249
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

40250


40251
# endif                                /* USE_RTMODEL */

40252


40253
        /* Allocate memory of model methods 2 */

40254
        {

40255
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

40256
            malloc(sizeof(struct _ssSFcnModelMethods2));

40257
          ss_VALIDATE_MEMORY(rts,methods2);

40258
          ssSetModelMethods2(childS, methods2);

40259
        }

40260


40261
        /* Allocate memory of model methods 3 */

40262
        {

40263
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

40264
            malloc(sizeof(struct _ssSFcnModelMethods3));

40265
          ss_VALIDATE_MEMORY(rts,methods3);

40266
          ssSetModelMethods3(childS, methods3);

40267
        }

40268


40269
        /* Allocate memory for states auxilliary information */

40270
        {

40271
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

40272
            (sizeof(struct _ssStatesInfo2));

40273
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

40274
            malloc(sizeof(ssPeriodicStatesInfo));

40275
          ss_VALIDATE_MEMORY(rts,statesInfo2);

40276
          ssSetStatesInfo2(childS, statesInfo2);

40277
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

40278
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

40279
        }

40280


40281
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

40282
          RegNumInputPorts);

40283
        ssSetRegNumInputPortsFcnArg(childS,childS);

40284


40285
        /* inputs */

40286
        {

40287
          struct _ssPortInputs *inputPortInfo =

40288
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

40289
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

40290
          _ssSetNumInputPorts(childS, 2);

40291
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

40292


40293
          /* port 0 */

40294
          {

40295
            real32_T const **sfcnUPtrs = (real32_T const **)

40296
              malloc(1 * sizeof(real32_T *));

40297
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40298
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40299
              ssGetLocalBlockIO(rts))->GeneratedSFunction_l;

40300
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

40301
            _ssSetInputPortNumDimensions(childS, 0, 1);

40302
            ssSetInputPortWidth(childS, 0, 1);

40303
          }

40304


40305
          /* port 1 */

40306
          {

40307
            real32_T const **sfcnUPtrs = (real32_T const **)

40308
              malloc(1 * sizeof(real32_T *));

40309
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40310
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;

40311
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

40312
            _ssSetInputPortNumDimensions(childS, 1, 1);

40313
            ssSetInputPortWidth(childS, 1, 1);

40314
          }

40315
        }

40316


40317
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

40318
          RegNumOutputPorts);

40319
        ssSetRegNumOutputPortsFcnArg(childS,childS);

40320


40321
        /* outputs */

40322
        {

40323
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

40324
            calloc(1, sizeof(struct _ssPortOutputs));

40325
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

40326
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

40327
          _ssSetNumOutputPorts(childS, 1);

40328


40329
          /* port 0 */

40330
          {

40331
            _ssSetOutputPortNumDimensions(childS, 0, 1);

40332
            ssSetOutputPortWidth(childS, 0, 1);

40333
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

40334
              ssGetLocalBlockIO(rts))->Saturation9));

40335
          }

40336
        }

40337


40338
        /* path info */

40339
        _ssSetModelName(childS, "Gain_sf");

40340
        _ssSetPath(childS,

40341
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain4/Generated S-Function");

40342
        if (ssGetRTModel(rts) == (NULL)) {

40343
          _ssSetParentSS(childS, rts);

40344
          _ssSetRootSS(childS, ssGetRootSS(rts));

40345
        } else {

40346
          ssSetRTModel(childS,ssGetRTModel(rts));

40347
          _ssSetParentSS(childS, (NULL));

40348
          _ssSetRootSS(childS, childS);

40349
        }

40350


40351
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

40352
        (childS)->regDataType.arg1 = ((void *)(childS));

40353
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

40354
          FcnSetErrorStatus);

40355
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

40356
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

40357
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

40358
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

40359


40360
        /* registration */

40361
#if defined(MATLAB_MEX_FILE)

40362


40363
        {

40364
          int_T i;

40365
          mxArray *plhs[1];

40366
          mxArray *prhs[4];

40367
          double *pr;

40368
          volatile int_T *intS = (int_T *)&childS;

40369
          int_T addrlen = sizeof(SimStruct *);

40370
          int_T m = addrlen/sizeof(int_T) + 1;

40371
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

40372
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

40373
          pr = mxGetPr(prhs[1]);

40374
          for (i = 0; i < m - 1; i++) {

40375
            pr[i] = (double)intS[i];

40376
          }

40377


40378
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

40379
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

40380
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

40381


40382
          /* Reset port dimensions info functions because the S-function

40383
           * and accelerator mex-files explicitly set their dimensions,

40384
           * i.e., they are not dynamically sized. For this case, the

40385
           * mex-file is responsible for the dimensions info memory

40386
           * and Simulink should not free it. This is achieved by

40387
           * setting the following two methods to NULL.

40388
           */

40389
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

40390
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

40391


40392
          /*

40393
           * Setup function pointers and call mdlInitializeSizes via

40394
           * simulink.c

40395
           */

40396
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

40397
          mxDestroyArray(plhs[0]);

40398
          mxDestroyArray(prhs[0]);

40399
          mxDestroyArray(prhs[1]);

40400
          mxDestroyArray(prhs[2]);

40401
          mxDestroyArray(prhs[3]);

40402
        }

40403


40404
#else

40405


40406
        {

40407
          Gain_sf(childS);

40408
          sfcnInitializeSizes(childS);

40409
        }

40410


40411
#endif

40412


40413
        sfcnInitializeSampleTimes(childS);

40414


40415
        /* adjust sample time */

40416
        ssSetSampleTime(childS, 0, 0.0);

40417
        ssSetOffsetTime(childS, 0, 0.0);

40418
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

40419


40420
        /* set compiled values of dynamic vector attributes */

40421
        ssSetNumNonsampledZCs(childS, 0);

40422


40423
        /* Update connectivity flags for each port */

40424
        _ssSetInputPortConnected(childS, 0, 1);

40425
        _ssSetInputPortConnected(childS, 1, 1);

40426
        _ssSetOutputPortConnected(childS, 0, 1);

40427
        _ssSetOutputPortBeingMerged(childS, 0, 0);

40428


40429
        /* Update the BufferDstPort flags for each input port */

40430
        _ssSetInputPortBufferDstPort(childS, 0, -1);

40431
        _ssSetInputPortBufferDstPort(childS, 1, -1);

40432
      }

40433


40434
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S264>/Generated S-Function (Gain_sf) */

40435
      {

40436
        SimStruct *childS = ssGetSFunction(rts, 154);

40437


40438
        /* timing info */

40439
        time_T *sfcnPeriod;

40440
        time_T *sfcnOffset;

40441
        int_T *sfcnTsMap;

40442
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

40443
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

40444
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

40445
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

40446
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

40447
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

40448
        (void) memset((void*)sfcnPeriod, 0,

40449
                      sizeof(time_T)*1);

40450
        (void) memset((void*)sfcnOffset, 0,

40451
                      sizeof(time_T)*1);

40452
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

40453
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

40454
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

40455


40456
        /* Set up the mdlInfo pointer */

40457
# ifdef USE_RTMODEL

40458


40459
        {

40460
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

40461
              struct _ssBlkInfo2));

40462
          ss_VALIDATE_MEMORY(rts,blkInfo2);

40463
          ssSetBlkInfo2Ptr(childS, blkInfo2);

40464
        }

40465


40466
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

40467


40468
# else

40469


40470
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

40471


40472
# endif                                /* USE_RTMODEL */

40473


40474
        /* Allocate memory of model methods 2 */

40475
        {

40476
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

40477
            malloc(sizeof(struct _ssSFcnModelMethods2));

40478
          ss_VALIDATE_MEMORY(rts,methods2);

40479
          ssSetModelMethods2(childS, methods2);

40480
        }

40481


40482
        /* Allocate memory of model methods 3 */

40483
        {

40484
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

40485
            malloc(sizeof(struct _ssSFcnModelMethods3));

40486
          ss_VALIDATE_MEMORY(rts,methods3);

40487
          ssSetModelMethods3(childS, methods3);

40488
        }

40489


40490
        /* Allocate memory for states auxilliary information */

40491
        {

40492
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

40493
            (sizeof(struct _ssStatesInfo2));

40494
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

40495
            malloc(sizeof(ssPeriodicStatesInfo));

40496
          ss_VALIDATE_MEMORY(rts,statesInfo2);

40497
          ssSetStatesInfo2(childS, statesInfo2);

40498
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

40499
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

40500
        }

40501


40502
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

40503
          RegNumInputPorts);

40504
        ssSetRegNumInputPortsFcnArg(childS,childS);

40505


40506
        /* inputs */

40507
        {

40508
          struct _ssPortInputs *inputPortInfo =

40509
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

40510
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

40511
          _ssSetNumInputPorts(childS, 2);

40512
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

40513


40514
          /* port 0 */

40515
          {

40516
            real32_T const **sfcnUPtrs = (real32_T const **)

40517
              malloc(1 * sizeof(real32_T *));

40518
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40519
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40520
              ssGetLocalBlockIO(rts))->UnitDelay1_c;

40521
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

40522
            _ssSetInputPortNumDimensions(childS, 0, 1);

40523
            ssSetInputPortWidth(childS, 0, 1);

40524
          }

40525


40526
          /* port 1 */

40527
          {

40528
            real32_T const **sfcnUPtrs = (real32_T const **)

40529
              malloc(1 * sizeof(real32_T *));

40530
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40531
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

40532
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

40533
            _ssSetInputPortNumDimensions(childS, 1, 1);

40534
            ssSetInputPortWidth(childS, 1, 1);

40535
          }

40536
        }

40537


40538
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

40539
          RegNumOutputPorts);

40540
        ssSetRegNumOutputPortsFcnArg(childS,childS);

40541


40542
        /* outputs */

40543
        {

40544
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

40545
            calloc(1, sizeof(struct _ssPortOutputs));

40546
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

40547
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

40548
          _ssSetNumOutputPorts(childS, 1);

40549


40550
          /* port 0 */

40551
          {

40552
            _ssSetOutputPortNumDimensions(childS, 0, 1);

40553
            ssSetOutputPortWidth(childS, 0, 1);

40554
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

40555
              ssGetLocalBlockIO(rts))->GeneratedSFunction_mt));

40556
          }

40557
        }

40558


40559
        /* path info */

40560
        _ssSetModelName(childS, "Gain_sf");

40561
        _ssSetPath(childS,

40562
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain8/Generated S-Function");

40563
        if (ssGetRTModel(rts) == (NULL)) {

40564
          _ssSetParentSS(childS, rts);

40565
          _ssSetRootSS(childS, ssGetRootSS(rts));

40566
        } else {

40567
          ssSetRTModel(childS,ssGetRTModel(rts));

40568
          _ssSetParentSS(childS, (NULL));

40569
          _ssSetRootSS(childS, childS);

40570
        }

40571


40572
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

40573
        (childS)->regDataType.arg1 = ((void *)(childS));

40574
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

40575
          FcnSetErrorStatus);

40576
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

40577
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

40578
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

40579
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

40580


40581
        /* registration */

40582
#if defined(MATLAB_MEX_FILE)

40583


40584
        {

40585
          int_T i;

40586
          mxArray *plhs[1];

40587
          mxArray *prhs[4];

40588
          double *pr;

40589
          volatile int_T *intS = (int_T *)&childS;

40590
          int_T addrlen = sizeof(SimStruct *);

40591
          int_T m = addrlen/sizeof(int_T) + 1;

40592
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

40593
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

40594
          pr = mxGetPr(prhs[1]);

40595
          for (i = 0; i < m - 1; i++) {

40596
            pr[i] = (double)intS[i];

40597
          }

40598


40599
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

40600
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

40601
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

40602


40603
          /* Reset port dimensions info functions because the S-function

40604
           * and accelerator mex-files explicitly set their dimensions,

40605
           * i.e., they are not dynamically sized. For this case, the

40606
           * mex-file is responsible for the dimensions info memory

40607
           * and Simulink should not free it. This is achieved by

40608
           * setting the following two methods to NULL.

40609
           */

40610
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

40611
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

40612


40613
          /*

40614
           * Setup function pointers and call mdlInitializeSizes via

40615
           * simulink.c

40616
           */

40617
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

40618
          mxDestroyArray(plhs[0]);

40619
          mxDestroyArray(prhs[0]);

40620
          mxDestroyArray(prhs[1]);

40621
          mxDestroyArray(prhs[2]);

40622
          mxDestroyArray(prhs[3]);

40623
        }

40624


40625
#else

40626


40627
        {

40628
          Gain_sf(childS);

40629
          sfcnInitializeSizes(childS);

40630
        }

40631


40632
#endif

40633


40634
        sfcnInitializeSampleTimes(childS);

40635


40636
        /* adjust sample time */

40637
        ssSetSampleTime(childS, 0, 0.005);

40638
        ssSetOffsetTime(childS, 0, 0.0);

40639
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];

40640


40641
        /* set compiled values of dynamic vector attributes */

40642
        ssSetNumNonsampledZCs(childS, 0);

40643


40644
        /* Update connectivity flags for each port */

40645
        _ssSetInputPortConnected(childS, 0, 1);

40646
        _ssSetInputPortConnected(childS, 1, 1);

40647
        _ssSetOutputPortConnected(childS, 0, 1);

40648
        _ssSetOutputPortBeingMerged(childS, 0, 0);

40649


40650
        /* Update the BufferDstPort flags for each input port */

40651
        _ssSetInputPortBufferDstPort(childS, 0, -1);

40652
        _ssSetInputPortBufferDstPort(childS, 1, -1);

40653
      }

40654


40655
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S257>/Generated S-Function3 (IntegratorLimited_sf) */

40656
      {

40657
        SimStruct *childS = ssGetSFunction(rts, 155);

40658


40659
        /* timing info */

40660
        time_T *sfcnPeriod;

40661
        time_T *sfcnOffset;

40662
        int_T *sfcnTsMap;

40663
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

40664
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

40665
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

40666
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

40667
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

40668
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

40669
        (void) memset((void*)sfcnPeriod, 0,

40670
                      sizeof(time_T)*1);

40671
        (void) memset((void*)sfcnOffset, 0,

40672
                      sizeof(time_T)*1);

40673
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

40674
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

40675
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

40676


40677
        /* Set up the mdlInfo pointer */

40678
# ifdef USE_RTMODEL

40679


40680
        {

40681
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

40682
              struct _ssBlkInfo2));

40683
          ss_VALIDATE_MEMORY(rts,blkInfo2);

40684
          ssSetBlkInfo2Ptr(childS, blkInfo2);

40685
        }

40686


40687
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

40688


40689
# else

40690


40691
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

40692


40693
# endif                                /* USE_RTMODEL */

40694


40695
        /* Allocate memory of model methods 2 */

40696
        {

40697
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

40698
            malloc(sizeof(struct _ssSFcnModelMethods2));

40699
          ss_VALIDATE_MEMORY(rts,methods2);

40700
          ssSetModelMethods2(childS, methods2);

40701
        }

40702


40703
        /* Allocate memory of model methods 3 */

40704
        {

40705
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

40706
            malloc(sizeof(struct _ssSFcnModelMethods3));

40707
          ss_VALIDATE_MEMORY(rts,methods3);

40708
          ssSetModelMethods3(childS, methods3);

40709
        }

40710


40711
        /* Allocate memory for states auxilliary information */

40712
        {

40713
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

40714
            (sizeof(struct _ssStatesInfo2));

40715
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

40716
            malloc(sizeof(ssPeriodicStatesInfo));

40717
          ss_VALIDATE_MEMORY(rts,statesInfo2);

40718
          ssSetStatesInfo2(childS, statesInfo2);

40719
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

40720
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

40721
        }

40722


40723
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

40724
          RegNumInputPorts);

40725
        ssSetRegNumInputPortsFcnArg(childS,childS);

40726


40727
        /* inputs */

40728
        {

40729
          struct _ssPortInputs *inputPortInfo =

40730
            (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));

40731
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

40732
          _ssSetNumInputPorts(childS, 7);

40733
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

40734


40735
          /* port 0 */

40736
          {

40737
            real32_T const **sfcnUPtrs = (real32_T const **)

40738
              malloc(1 * sizeof(real32_T *));

40739
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40740
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40741
              ssGetLocalBlockIO(rts))->dtCAS;

40742
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

40743
            _ssSetInputPortNumDimensions(childS, 0, 1);

40744
            ssSetInputPortWidth(childS, 0, 1);

40745
          }

40746


40747
          /* port 1 */

40748
          {

40749
            int8_T const **sfcnUPtrs = (int8_T const **)

40750
              malloc(1 * sizeof(int8_T *));

40751
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40752
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

40753
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

40754
            _ssSetInputPortNumDimensions(childS, 1, 1);

40755
            ssSetInputPortWidth(childS, 1, 1);

40756
          }

40757


40758
          /* port 2 */

40759
          {

40760
            real32_T const **sfcnUPtrs = (real32_T const **)

40761
              malloc(1 * sizeof(real32_T *));

40762
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40763
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40764
              ssGetLocalBlockIO(rts))->Sum4_iv;

40765
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

40766
            _ssSetInputPortNumDimensions(childS, 2, 1);

40767
            ssSetInputPortWidth(childS, 2, 1);

40768
          }

40769


40770
          /* port 3 */

40771
          {

40772
            real32_T const **sfcnUPtrs = (real32_T const **)

40773
              malloc(1 * sizeof(real32_T *));

40774
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40775
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40776
              ssGetLocalBlockIO(rts))->Sum4_iv;

40777
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

40778
            _ssSetInputPortNumDimensions(childS, 3, 1);

40779
            ssSetInputPortWidth(childS, 3, 1);

40780
          }

40781


40782
          /* port 4 */

40783
          {

40784
            real32_T const **sfcnUPtrs = (real32_T const **)

40785
              malloc(1 * sizeof(real32_T *));

40786
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40787
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40788
              ssGetLocalBlockIO(rts))->Add4;

40789
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

40790
            _ssSetInputPortNumDimensions(childS, 4, 1);

40791
            ssSetInputPortWidth(childS, 4, 1);

40792
          }

40793


40794
          /* port 5 */

40795
          {

40796
            real32_T const **sfcnUPtrs = (real32_T const **)

40797
              malloc(1 * sizeof(real32_T *));

40798
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40799
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40800
              ssGetLocalBlockIO(rts))->Add5;

40801
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

40802
            _ssSetInputPortNumDimensions(childS, 5, 1);

40803
            ssSetInputPortWidth(childS, 5, 1);

40804
          }

40805


40806
          /* port 6 */

40807
          {

40808
            real32_T const **sfcnUPtrs = (real32_T const **)

40809
              malloc(1 * sizeof(real32_T *));

40810
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

40811
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

40812
              ssGetLocalBlockIO(rts))->Sum11_c;

40813
            _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);

40814
            _ssSetInputPortNumDimensions(childS, 6, 1);

40815
            ssSetInputPortWidth(childS, 6, 1);

40816
          }

40817
        }

40818


40819
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

40820
          RegNumOutputPorts);

40821
        ssSetRegNumOutputPortsFcnArg(childS,childS);

40822


40823
        /* outputs */

40824
        {

40825
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

40826
            calloc(1, sizeof(struct _ssPortOutputs));

40827
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

40828
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

40829
          _ssSetNumOutputPorts(childS, 1);

40830


40831
          /* port 0 */

40832
          {

40833
            _ssSetOutputPortNumDimensions(childS, 0, 1);

40834
            ssSetOutputPortWidth(childS, 0, 1);

40835
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

40836
              ssGetLocalBlockIO(rts))->deint));

40837
          }

40838
        }

40839


40840
        /* path info */

40841
        _ssSetModelName(childS, "IntegratorLimited_sf");

40842
        _ssSetPath(childS,

40843
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/Integrator Limited/Generated S-Function3");

40844
        if (ssGetRTModel(rts) == (NULL)) {

40845
          _ssSetParentSS(childS, rts);

40846
          _ssSetRootSS(childS, ssGetRootSS(rts));

40847
        } else {

40848
          ssSetRTModel(childS,ssGetRTModel(rts));

40849
          _ssSetParentSS(childS, (NULL));

40850
          _ssSetRootSS(childS, childS);

40851
        }

40852


40853
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

40854


40855
        /* work vectors */

40856
        {

40857
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

40858
            (4 * sizeof(struct _ssDWorkRecord));

40859
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

40860
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

40861
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

40862
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

40863
          ssSetSFcnDWork(childS, dWorkRecord);

40864
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

40865
          _ssSetNumDWork(childS, 4);

40866


40867
          /* DWORK0 */

40868
          ssSetDWorkWidth(childS, 0, 1);

40869
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

40870
          ssSetDWorkComplexSignal(childS, 0, 0);

40871
          ssSetDWorkUsedAsDState(childS, 0, 1);

40872
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 263))[0]);

40873


40874
          /* DWORK1 */

40875
          ssSetDWorkWidth(childS, 1, 1);

40876
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

40877
          ssSetDWorkComplexSignal(childS, 1, 0);

40878
          ssSetDWorkUsedAsDState(childS, 1, 1);

40879
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 264))[0]);

40880


40881
          /* DWORK2 */

40882
          ssSetDWorkWidth(childS, 2, 1);

40883
          ssSetDWorkDataType(childS, 2,SS_INT8);

40884
          ssSetDWorkComplexSignal(childS, 2, 0);

40885
          ssSetDWorkUsedAsDState(childS, 2, 1);

40886
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 492))[0]);

40887


40888
          /* DWORK3 */

40889
          ssSetDWorkWidth(childS, 3, 1);

40890
          ssSetDWorkDataType(childS, 3,SS_INT8);

40891
          ssSetDWorkComplexSignal(childS, 3, 0);

40892
          ssSetDWorkUsedAsDState(childS, 3, 1);

40893
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 493))[0]);

40894
        }

40895


40896
        (childS)->regDataType.arg1 = ((void *)(childS));

40897
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

40898
          FcnSetErrorStatus);

40899
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

40900
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

40901
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

40902
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

40903


40904
        /* registration */

40905
#if defined(MATLAB_MEX_FILE)

40906


40907
        {

40908
          int_T i;

40909
          mxArray *plhs[1];

40910
          mxArray *prhs[4];

40911
          double *pr;

40912
          volatile int_T *intS = (int_T *)&childS;

40913
          int_T addrlen = sizeof(SimStruct *);

40914
          int_T m = addrlen/sizeof(int_T) + 1;

40915
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

40916
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

40917
          pr = mxGetPr(prhs[1]);

40918
          for (i = 0; i < m - 1; i++) {

40919
            pr[i] = (double)intS[i];

40920
          }

40921


40922
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

40923
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

40924
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

40925


40926
          /* Reset port dimensions info functions because the S-function

40927
           * and accelerator mex-files explicitly set their dimensions,

40928
           * i.e., they are not dynamically sized. For this case, the

40929
           * mex-file is responsible for the dimensions info memory

40930
           * and Simulink should not free it. This is achieved by

40931
           * setting the following two methods to NULL.

40932
           */

40933
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

40934
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

40935


40936
          /*

40937
           * Setup function pointers and call mdlInitializeSizes via

40938
           * simulink.c

40939
           */

40940
          mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");

40941
          mxDestroyArray(plhs[0]);

40942
          mxDestroyArray(prhs[0]);

40943
          mxDestroyArray(prhs[1]);

40944
          mxDestroyArray(prhs[2]);

40945
          mxDestroyArray(prhs[3]);

40946
        }

40947


40948
#else

40949


40950
        {

40951
          IntegratorLimited_sf(childS);

40952
          sfcnInitializeSizes(childS);

40953
        }

40954


40955
#endif

40956


40957
        sfcnInitializeSampleTimes(childS);

40958


40959
        /* adjust sample time */

40960
        ssSetSampleTime(childS, 0, 0.0);

40961
        ssSetOffsetTime(childS, 0, 0.0);

40962
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

40963


40964
        /* set compiled values of dynamic vector attributes */

40965
        ssSetNumNonsampledZCs(childS, 0);

40966


40967
        /* Update connectivity flags for each port */

40968
        _ssSetInputPortConnected(childS, 0, 1);

40969
        _ssSetInputPortConnected(childS, 1, 1);

40970
        _ssSetInputPortConnected(childS, 2, 1);

40971
        _ssSetInputPortConnected(childS, 3, 1);

40972
        _ssSetInputPortConnected(childS, 4, 1);

40973
        _ssSetInputPortConnected(childS, 5, 1);

40974
        _ssSetInputPortConnected(childS, 6, 1);

40975
        _ssSetOutputPortConnected(childS, 0, 1);

40976
        _ssSetOutputPortBeingMerged(childS, 0, 0);

40977


40978
        /* Update the BufferDstPort flags for each input port */

40979
        _ssSetInputPortBufferDstPort(childS, 0, -1);

40980
        _ssSetInputPortBufferDstPort(childS, 1, -1);

40981
        _ssSetInputPortBufferDstPort(childS, 2, -1);

40982
        _ssSetInputPortBufferDstPort(childS, 3, -1);

40983
        _ssSetInputPortBufferDstPort(childS, 4, -1);

40984
        _ssSetInputPortBufferDstPort(childS, 5, -1);

40985
        _ssSetInputPortBufferDstPort(childS, 6, -1);

40986
      }

40987


40988
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S250>/Generated S-Function1 (SaturationLimiter_sf) */

40989
      {

40990
        SimStruct *childS = ssGetSFunction(rts, 156);

40991


40992
        /* timing info */

40993
        time_T *sfcnPeriod;

40994
        time_T *sfcnOffset;

40995
        int_T *sfcnTsMap;

40996
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

40997
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

40998
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

40999
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

41000
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

41001
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

41002
        (void) memset((void*)sfcnPeriod, 0,

41003
                      sizeof(time_T)*1);

41004
        (void) memset((void*)sfcnOffset, 0,

41005
                      sizeof(time_T)*1);

41006
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

41007
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

41008
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

41009


41010
        /* Set up the mdlInfo pointer */

41011
# ifdef USE_RTMODEL

41012


41013
        {

41014
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

41015
              struct _ssBlkInfo2));

41016
          ss_VALIDATE_MEMORY(rts,blkInfo2);

41017
          ssSetBlkInfo2Ptr(childS, blkInfo2);

41018
        }

41019


41020
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

41021


41022
# else

41023


41024
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

41025


41026
# endif                                /* USE_RTMODEL */

41027


41028
        /* Allocate memory of model methods 2 */

41029
        {

41030
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

41031
            malloc(sizeof(struct _ssSFcnModelMethods2));

41032
          ss_VALIDATE_MEMORY(rts,methods2);

41033
          ssSetModelMethods2(childS, methods2);

41034
        }

41035


41036
        /* Allocate memory of model methods 3 */

41037
        {

41038
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

41039
            malloc(sizeof(struct _ssSFcnModelMethods3));

41040
          ss_VALIDATE_MEMORY(rts,methods3);

41041
          ssSetModelMethods3(childS, methods3);

41042
        }

41043


41044
        /* Allocate memory for states auxilliary information */

41045
        {

41046
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

41047
            (sizeof(struct _ssStatesInfo2));

41048
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

41049
            malloc(sizeof(ssPeriodicStatesInfo));

41050
          ss_VALIDATE_MEMORY(rts,statesInfo2);

41051
          ssSetStatesInfo2(childS, statesInfo2);

41052
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

41053
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

41054
        }

41055


41056
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

41057
          RegNumInputPorts);

41058
        ssSetRegNumInputPortsFcnArg(childS,childS);

41059


41060
        /* inputs */

41061
        {

41062
          struct _ssPortInputs *inputPortInfo =

41063
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

41064
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

41065
          _ssSetNumInputPorts(childS, 3);

41066
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

41067


41068
          /* port 0 */

41069
          {

41070
            real32_T const **sfcnUPtrs = (real32_T const **)

41071
              malloc(1 * sizeof(real32_T *));

41072
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41073
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

41074
              ssGetLocalBlockIO(rts))->Switch_m;

41075
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

41076
            _ssSetInputPortNumDimensions(childS, 0, 1);

41077
            ssSetInputPortWidth(childS, 0, 1);

41078
          }

41079


41080
          /* port 1 */

41081
          {

41082
            real32_T const **sfcnUPtrs = (real32_T const **)

41083
              malloc(1 * sizeof(real32_T *));

41084
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41085
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;

41086
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

41087
            _ssSetInputPortNumDimensions(childS, 1, 1);

41088
            ssSetInputPortWidth(childS, 1, 1);

41089
          }

41090


41091
          /* port 2 */

41092
          {

41093
            real32_T const **sfcnUPtrs = (real32_T const **)

41094
              malloc(1 * sizeof(real32_T *));

41095
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41096
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;

41097
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

41098
            _ssSetInputPortNumDimensions(childS, 2, 1);

41099
            ssSetInputPortWidth(childS, 2, 1);

41100
          }

41101
        }

41102


41103
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

41104
          RegNumOutputPorts);

41105
        ssSetRegNumOutputPortsFcnArg(childS,childS);

41106


41107
        /* outputs */

41108
        {

41109
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

41110
            calloc(1, sizeof(struct _ssPortOutputs));

41111
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

41112
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

41113
          _ssSetNumOutputPorts(childS, 1);

41114


41115
          /* port 0 */

41116
          {

41117
            _ssSetOutputPortNumDimensions(childS, 0, 1);

41118
            ssSetOutputPortWidth(childS, 0, 1);

41119
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

41120
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_pc));

41121
          }

41122
        }

41123


41124
        /* path info */

41125
        _ssSetModelName(childS, "SaturationLimiter_sf");

41126
        _ssSetPath(childS,

41127
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/Saturation Limiter4/Generated S-Function1");

41128
        if (ssGetRTModel(rts) == (NULL)) {

41129
          _ssSetParentSS(childS, rts);

41130
          _ssSetRootSS(childS, ssGetRootSS(rts));

41131
        } else {

41132
          ssSetRTModel(childS,ssGetRTModel(rts));

41133
          _ssSetParentSS(childS, (NULL));

41134
          _ssSetRootSS(childS, childS);

41135
        }

41136


41137
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

41138
        (childS)->regDataType.arg1 = ((void *)(childS));

41139
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

41140
          FcnSetErrorStatus);

41141
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

41142
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

41143
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

41144
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

41145


41146
        /* registration */

41147
#if defined(MATLAB_MEX_FILE)

41148


41149
        {

41150
          int_T i;

41151
          mxArray *plhs[1];

41152
          mxArray *prhs[4];

41153
          double *pr;

41154
          volatile int_T *intS = (int_T *)&childS;

41155
          int_T addrlen = sizeof(SimStruct *);

41156
          int_T m = addrlen/sizeof(int_T) + 1;

41157
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

41158
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

41159
          pr = mxGetPr(prhs[1]);

41160
          for (i = 0; i < m - 1; i++) {

41161
            pr[i] = (double)intS[i];

41162
          }

41163


41164
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

41165
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

41166
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

41167


41168
          /* Reset port dimensions info functions because the S-function

41169
           * and accelerator mex-files explicitly set their dimensions,

41170
           * i.e., they are not dynamically sized. For this case, the

41171
           * mex-file is responsible for the dimensions info memory

41172
           * and Simulink should not free it. This is achieved by

41173
           * setting the following two methods to NULL.

41174
           */

41175
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

41176
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

41177


41178
          /*

41179
           * Setup function pointers and call mdlInitializeSizes via

41180
           * simulink.c

41181
           */

41182
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

41183
          mxDestroyArray(plhs[0]);

41184
          mxDestroyArray(prhs[0]);

41185
          mxDestroyArray(prhs[1]);

41186
          mxDestroyArray(prhs[2]);

41187
          mxDestroyArray(prhs[3]);

41188
        }

41189


41190
#else

41191


41192
        {

41193
          SaturationLimiter_sf(childS);

41194
          sfcnInitializeSizes(childS);

41195
        }

41196


41197
#endif

41198


41199
        sfcnInitializeSampleTimes(childS);

41200


41201
        /* adjust sample time */

41202
        ssSetSampleTime(childS, 0, 0.0);

41203
        ssSetOffsetTime(childS, 0, 0.0);

41204
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

41205


41206
        /* set compiled values of dynamic vector attributes */

41207
        ssSetNumNonsampledZCs(childS, 0);

41208


41209
        /* Update connectivity flags for each port */

41210
        _ssSetInputPortConnected(childS, 0, 1);

41211
        _ssSetInputPortConnected(childS, 1, 1);

41212
        _ssSetInputPortConnected(childS, 2, 1);

41213
        _ssSetOutputPortConnected(childS, 0, 1);

41214
        _ssSetOutputPortBeingMerged(childS, 0, 0);

41215


41216
        /* Update the BufferDstPort flags for each input port */

41217
        _ssSetInputPortBufferDstPort(childS, 0, -1);

41218
        _ssSetInputPortBufferDstPort(childS, 1, -1);

41219
        _ssSetInputPortBufferDstPort(childS, 2, -1);

41220
      }

41221


41222
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S249>/Generated S-Function7 (RateLimiter_sf) */

41223
      {

41224
        SimStruct *childS = ssGetSFunction(rts, 157);

41225


41226
        /* timing info */

41227
        time_T *sfcnPeriod;

41228
        time_T *sfcnOffset;

41229
        int_T *sfcnTsMap;

41230
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

41231
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

41232
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

41233
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

41234
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

41235
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

41236
        (void) memset((void*)sfcnPeriod, 0,

41237
                      sizeof(time_T)*1);

41238
        (void) memset((void*)sfcnOffset, 0,

41239
                      sizeof(time_T)*1);

41240
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

41241
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

41242
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

41243


41244
        /* Set up the mdlInfo pointer */

41245
# ifdef USE_RTMODEL

41246


41247
        {

41248
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

41249
              struct _ssBlkInfo2));

41250
          ss_VALIDATE_MEMORY(rts,blkInfo2);

41251
          ssSetBlkInfo2Ptr(childS, blkInfo2);

41252
        }

41253


41254
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

41255


41256
# else

41257


41258
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

41259


41260
# endif                                /* USE_RTMODEL */

41261


41262
        /* Allocate memory of model methods 2 */

41263
        {

41264
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

41265
            malloc(sizeof(struct _ssSFcnModelMethods2));

41266
          ss_VALIDATE_MEMORY(rts,methods2);

41267
          ssSetModelMethods2(childS, methods2);

41268
        }

41269


41270
        /* Allocate memory of model methods 3 */

41271
        {

41272
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

41273
            malloc(sizeof(struct _ssSFcnModelMethods3));

41274
          ss_VALIDATE_MEMORY(rts,methods3);

41275
          ssSetModelMethods3(childS, methods3);

41276
        }

41277


41278
        /* Allocate memory for states auxilliary information */

41279
        {

41280
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

41281
            (sizeof(struct _ssStatesInfo2));

41282
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

41283
            malloc(sizeof(ssPeriodicStatesInfo));

41284
          ss_VALIDATE_MEMORY(rts,statesInfo2);

41285
          ssSetStatesInfo2(childS, statesInfo2);

41286
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

41287
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

41288
        }

41289


41290
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

41291
          RegNumInputPorts);

41292
        ssSetRegNumInputPortsFcnArg(childS,childS);

41293


41294
        /* inputs */

41295
        {

41296
          struct _ssPortInputs *inputPortInfo =

41297
            (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));

41298
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

41299
          _ssSetNumInputPorts(childS, 5);

41300
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

41301


41302
          /* port 0 */

41303
          {

41304
            int8_T const **sfcnUPtrs = (int8_T const **)

41305
              malloc(1 * sizeof(int8_T *));

41306
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41307
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

41308
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

41309
            _ssSetInputPortNumDimensions(childS, 0, 1);

41310
            ssSetInputPortWidth(childS, 0, 1);

41311
          }

41312


41313
          /* port 1 */

41314
          {

41315
            real32_T const **sfcnUPtrs = (real32_T const **)

41316
              malloc(1 * sizeof(real32_T *));

41317
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41318
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

41319
              ssGetLocalBlockIO(rts))->Gain_i;

41320
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

41321
            _ssSetInputPortNumDimensions(childS, 1, 1);

41322
            ssSetInputPortWidth(childS, 1, 1);

41323
          }

41324


41325
          /* port 2 */

41326
          {

41327
            real32_T const **sfcnUPtrs = (real32_T const **)

41328
              malloc(1 * sizeof(real32_T *));

41329
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41330
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled125;

41331
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

41332
            _ssSetInputPortNumDimensions(childS, 2, 1);

41333
            ssSetInputPortWidth(childS, 2, 1);

41334
          }

41335


41336
          /* port 3 */

41337
          {

41338
            real32_T const **sfcnUPtrs = (real32_T const **)

41339
              malloc(1 * sizeof(real32_T *));

41340
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41341
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

41342
              ssGetLocalBlockIO(rts))->dtCAS;

41343
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

41344
            _ssSetInputPortNumDimensions(childS, 3, 1);

41345
            ssSetInputPortWidth(childS, 3, 1);

41346
          }

41347


41348
          /* port 4 */

41349
          {

41350
            real32_T const **sfcnUPtrs = (real32_T const **)

41351
              malloc(1 * sizeof(real32_T *));

41352
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41353
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

41354
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_pc;

41355
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

41356
            _ssSetInputPortNumDimensions(childS, 4, 1);

41357
            ssSetInputPortWidth(childS, 4, 1);

41358
          }

41359
        }

41360


41361
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

41362
          RegNumOutputPorts);

41363
        ssSetRegNumOutputPortsFcnArg(childS,childS);

41364


41365
        /* outputs */

41366
        {

41367
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

41368
            calloc(2, sizeof(struct _ssPortOutputs));

41369
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

41370
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

41371
          _ssSetNumOutputPorts(childS, 2);

41372


41373
          /* port 0 */

41374
          {

41375
            _ssSetOutputPortNumDimensions(childS, 0, 1);

41376
            ssSetOutputPortWidth(childS, 0, 1);

41377
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

41378
              ssGetLocalBlockIO(rts))->daint));

41379
          }

41380


41381
          /* port 1 */

41382
          {

41383
            _ssSetOutputPortNumDimensions(childS, 1, 1);

41384
            ssSetOutputPortWidth(childS, 1, 1);

41385
            _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)

41386
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_i2));

41387
          }

41388
        }

41389


41390
        /* path info */

41391
        _ssSetModelName(childS, "RateLimiter_sf");

41392
        _ssSetPath(childS,

41393
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/Rate Limiter3/Generated S-Function7");

41394
        if (ssGetRTModel(rts) == (NULL)) {

41395
          _ssSetParentSS(childS, rts);

41396
          _ssSetRootSS(childS, ssGetRootSS(rts));

41397
        } else {

41398
          ssSetRTModel(childS,ssGetRTModel(rts));

41399
          _ssSetParentSS(childS, (NULL));

41400
          _ssSetRootSS(childS, childS);

41401
        }

41402


41403
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

41404


41405
        /* work vectors */

41406
        {

41407
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

41408
            (3 * sizeof(struct _ssDWorkRecord));

41409
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

41410
            calloc(3, sizeof(struct _ssDWorkAuxRecord));

41411
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

41412
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

41413
          ssSetSFcnDWork(childS, dWorkRecord);

41414
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

41415
          _ssSetNumDWork(childS, 3);

41416


41417
          /* DWORK0 */

41418
          ssSetDWorkWidth(childS, 0, 1);

41419
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

41420
          ssSetDWorkComplexSignal(childS, 0, 0);

41421
          ssSetDWorkUsedAsDState(childS, 0, 1);

41422
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 265))[0]);

41423


41424
          /* DWORK1 */

41425
          ssSetDWorkWidth(childS, 1, 1);

41426
          ssSetDWorkDataType(childS, 1,SS_INT8);

41427
          ssSetDWorkComplexSignal(childS, 1, 0);

41428
          ssSetDWorkUsedAsDState(childS, 1, 1);

41429
          _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 494))[0]);

41430


41431
          /* DWORK2 */

41432
          ssSetDWorkWidth(childS, 2, 1);

41433
          ssSetDWorkDataType(childS, 2,SS_INT8);

41434
          ssSetDWorkComplexSignal(childS, 2, 0);

41435
          ssSetDWorkUsedAsDState(childS, 2, 1);

41436
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 495))[0]);

41437
        }

41438


41439
        (childS)->regDataType.arg1 = ((void *)(childS));

41440
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

41441
          FcnSetErrorStatus);

41442
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

41443
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

41444
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

41445
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

41446


41447
        /* registration */

41448
#if defined(MATLAB_MEX_FILE)

41449


41450
        {

41451
          int_T i;

41452
          mxArray *plhs[1];

41453
          mxArray *prhs[4];

41454
          double *pr;

41455
          volatile int_T *intS = (int_T *)&childS;

41456
          int_T addrlen = sizeof(SimStruct *);

41457
          int_T m = addrlen/sizeof(int_T) + 1;

41458
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

41459
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

41460
          pr = mxGetPr(prhs[1]);

41461
          for (i = 0; i < m - 1; i++) {

41462
            pr[i] = (double)intS[i];

41463
          }

41464


41465
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

41466
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

41467
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

41468


41469
          /* Reset port dimensions info functions because the S-function

41470
           * and accelerator mex-files explicitly set their dimensions,

41471
           * i.e., they are not dynamically sized. For this case, the

41472
           * mex-file is responsible for the dimensions info memory

41473
           * and Simulink should not free it. This is achieved by

41474
           * setting the following two methods to NULL.

41475
           */

41476
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

41477
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

41478


41479
          /*

41480
           * Setup function pointers and call mdlInitializeSizes via

41481
           * simulink.c

41482
           */

41483
          mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");

41484
          mxDestroyArray(plhs[0]);

41485
          mxDestroyArray(prhs[0]);

41486
          mxDestroyArray(prhs[1]);

41487
          mxDestroyArray(prhs[2]);

41488
          mxDestroyArray(prhs[3]);

41489
        }

41490


41491
#else

41492


41493
        {

41494
          RateLimiter_sf(childS);

41495
          sfcnInitializeSizes(childS);

41496
        }

41497


41498
#endif

41499


41500
        sfcnInitializeSampleTimes(childS);

41501


41502
        /* adjust sample time */

41503
        ssSetSampleTime(childS, 0, 0.0);

41504
        ssSetOffsetTime(childS, 0, 0.0);

41505
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

41506


41507
        /* set compiled values of dynamic vector attributes */

41508
        ssSetNumNonsampledZCs(childS, 0);

41509


41510
        /* Update connectivity flags for each port */

41511
        _ssSetInputPortConnected(childS, 0, 1);

41512
        _ssSetInputPortConnected(childS, 1, 1);

41513
        _ssSetInputPortConnected(childS, 2, 1);

41514
        _ssSetInputPortConnected(childS, 3, 1);

41515
        _ssSetInputPortConnected(childS, 4, 1);

41516
        _ssSetOutputPortConnected(childS, 0, 1);

41517
        _ssSetOutputPortConnected(childS, 1, 1);

41518
        _ssSetOutputPortBeingMerged(childS, 0, 0);

41519
        _ssSetOutputPortBeingMerged(childS, 1, 0);

41520


41521
        /* Update the BufferDstPort flags for each input port */

41522
        _ssSetInputPortBufferDstPort(childS, 0, -1);

41523
        _ssSetInputPortBufferDstPort(childS, 1, -1);

41524
        _ssSetInputPortBufferDstPort(childS, 2, -1);

41525
        _ssSetInputPortBufferDstPort(childS, 3, -1);

41526
        _ssSetInputPortBufferDstPort(childS, 4, -1);

41527
      }

41528


41529
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S275>/Generated S-Function1 (SaturationLimiter_sf) */

41530
      {

41531
        SimStruct *childS = ssGetSFunction(rts, 158);

41532


41533
        /* timing info */

41534
        time_T *sfcnPeriod;

41535
        time_T *sfcnOffset;

41536
        int_T *sfcnTsMap;

41537
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

41538
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

41539
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

41540
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

41541
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

41542
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

41543
        (void) memset((void*)sfcnPeriod, 0,

41544
                      sizeof(time_T)*1);

41545
        (void) memset((void*)sfcnOffset, 0,

41546
                      sizeof(time_T)*1);

41547
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

41548
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

41549
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

41550


41551
        /* Set up the mdlInfo pointer */

41552
# ifdef USE_RTMODEL

41553


41554
        {

41555
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

41556
              struct _ssBlkInfo2));

41557
          ss_VALIDATE_MEMORY(rts,blkInfo2);

41558
          ssSetBlkInfo2Ptr(childS, blkInfo2);

41559
        }

41560


41561
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

41562


41563
# else

41564


41565
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

41566


41567
# endif                                /* USE_RTMODEL */

41568


41569
        /* Allocate memory of model methods 2 */

41570
        {

41571
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

41572
            malloc(sizeof(struct _ssSFcnModelMethods2));

41573
          ss_VALIDATE_MEMORY(rts,methods2);

41574
          ssSetModelMethods2(childS, methods2);

41575
        }

41576


41577
        /* Allocate memory of model methods 3 */

41578
        {

41579
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

41580
            malloc(sizeof(struct _ssSFcnModelMethods3));

41581
          ss_VALIDATE_MEMORY(rts,methods3);

41582
          ssSetModelMethods3(childS, methods3);

41583
        }

41584


41585
        /* Allocate memory for states auxilliary information */

41586
        {

41587
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

41588
            (sizeof(struct _ssStatesInfo2));

41589
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

41590
            malloc(sizeof(ssPeriodicStatesInfo));

41591
          ss_VALIDATE_MEMORY(rts,statesInfo2);

41592
          ssSetStatesInfo2(childS, statesInfo2);

41593
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

41594
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

41595
        }

41596


41597
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

41598
          RegNumInputPorts);

41599
        ssSetRegNumInputPortsFcnArg(childS,childS);

41600


41601
        /* inputs */

41602
        {

41603
          struct _ssPortInputs *inputPortInfo =

41604
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

41605
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

41606
          _ssSetNumInputPorts(childS, 3);

41607
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

41608


41609
          /* port 0 */

41610
          {

41611
            real32_T const **sfcnUPtrs = (real32_T const **)

41612
              malloc(1 * sizeof(real32_T *));

41613
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41614
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

41615
              ssGetLocalBlockIO(rts))->Switch_i;

41616
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

41617
            _ssSetInputPortNumDimensions(childS, 0, 1);

41618
            ssSetInputPortWidth(childS, 0, 1);

41619
          }

41620


41621
          /* port 1 */

41622
          {

41623
            real32_T const **sfcnUPtrs = (real32_T const **)

41624
              malloc(1 * sizeof(real32_T *));

41625
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41626
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

41627
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

41628
            _ssSetInputPortNumDimensions(childS, 1, 1);

41629
            ssSetInputPortWidth(childS, 1, 1);

41630
          }

41631


41632
          /* port 2 */

41633
          {

41634
            real32_T const **sfcnUPtrs = (real32_T const **)

41635
              malloc(1 * sizeof(real32_T *));

41636
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41637
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

41638
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

41639
            _ssSetInputPortNumDimensions(childS, 2, 1);

41640
            ssSetInputPortWidth(childS, 2, 1);

41641
          }

41642
        }

41643


41644
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

41645
          RegNumOutputPorts);

41646
        ssSetRegNumOutputPortsFcnArg(childS,childS);

41647


41648
        /* outputs */

41649
        {

41650
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

41651
            calloc(1, sizeof(struct _ssPortOutputs));

41652
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

41653
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

41654
          _ssSetNumOutputPorts(childS, 1);

41655


41656
          /* port 0 */

41657
          {

41658
            _ssSetOutputPortNumDimensions(childS, 0, 1);

41659
            ssSetOutputPortWidth(childS, 0, 1);

41660
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

41661
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_hf));

41662
          }

41663
        }

41664


41665
        /* path info */

41666
        _ssSetModelName(childS, "SaturationLimiter_sf");

41667
        _ssSetPath(childS,

41668
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/sb/Saturation Limiter1/Generated S-Function1");

41669
        if (ssGetRTModel(rts) == (NULL)) {

41670
          _ssSetParentSS(childS, rts);

41671
          _ssSetRootSS(childS, ssGetRootSS(rts));

41672
        } else {

41673
          ssSetRTModel(childS,ssGetRTModel(rts));

41674
          _ssSetParentSS(childS, (NULL));

41675
          _ssSetRootSS(childS, childS);

41676
        }

41677


41678
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

41679
        (childS)->regDataType.arg1 = ((void *)(childS));

41680
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

41681
          FcnSetErrorStatus);

41682
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

41683
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

41684
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

41685
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

41686


41687
        /* registration */

41688
#if defined(MATLAB_MEX_FILE)

41689


41690
        {

41691
          int_T i;

41692
          mxArray *plhs[1];

41693
          mxArray *prhs[4];

41694
          double *pr;

41695
          volatile int_T *intS = (int_T *)&childS;

41696
          int_T addrlen = sizeof(SimStruct *);

41697
          int_T m = addrlen/sizeof(int_T) + 1;

41698
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

41699
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

41700
          pr = mxGetPr(prhs[1]);

41701
          for (i = 0; i < m - 1; i++) {

41702
            pr[i] = (double)intS[i];

41703
          }

41704


41705
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

41706
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

41707
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

41708


41709
          /* Reset port dimensions info functions because the S-function

41710
           * and accelerator mex-files explicitly set their dimensions,

41711
           * i.e., they are not dynamically sized. For this case, the

41712
           * mex-file is responsible for the dimensions info memory

41713
           * and Simulink should not free it. This is achieved by

41714
           * setting the following two methods to NULL.

41715
           */

41716
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

41717
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

41718


41719
          /*

41720
           * Setup function pointers and call mdlInitializeSizes via

41721
           * simulink.c

41722
           */

41723
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

41724
          mxDestroyArray(plhs[0]);

41725
          mxDestroyArray(prhs[0]);

41726
          mxDestroyArray(prhs[1]);

41727
          mxDestroyArray(prhs[2]);

41728
          mxDestroyArray(prhs[3]);

41729
        }

41730


41731
#else

41732


41733
        {

41734
          SaturationLimiter_sf(childS);

41735
          sfcnInitializeSizes(childS);

41736
        }

41737


41738
#endif

41739


41740
        sfcnInitializeSampleTimes(childS);

41741


41742
        /* adjust sample time */

41743
        ssSetSampleTime(childS, 0, 0.0);

41744
        ssSetOffsetTime(childS, 0, 0.0);

41745
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

41746


41747
        /* set compiled values of dynamic vector attributes */

41748
        ssSetNumNonsampledZCs(childS, 0);

41749


41750
        /* Update connectivity flags for each port */

41751
        _ssSetInputPortConnected(childS, 0, 1);

41752
        _ssSetInputPortConnected(childS, 1, 1);

41753
        _ssSetInputPortConnected(childS, 2, 1);

41754
        _ssSetOutputPortConnected(childS, 0, 1);

41755
        _ssSetOutputPortBeingMerged(childS, 0, 0);

41756


41757
        /* Update the BufferDstPort flags for each input port */

41758
        _ssSetInputPortBufferDstPort(childS, 0, -1);

41759
        _ssSetInputPortBufferDstPort(childS, 1, -1);

41760
        _ssSetInputPortBufferDstPort(childS, 2, -1);

41761
      }

41762


41763
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S274>/Generated S-Function7 (RateLimiter_sf) */

41764
      {

41765
        SimStruct *childS = ssGetSFunction(rts, 159);

41766


41767
        /* timing info */

41768
        time_T *sfcnPeriod;

41769
        time_T *sfcnOffset;

41770
        int_T *sfcnTsMap;

41771
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

41772
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

41773
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

41774
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

41775
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

41776
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

41777
        (void) memset((void*)sfcnPeriod, 0,

41778
                      sizeof(time_T)*1);

41779
        (void) memset((void*)sfcnOffset, 0,

41780
                      sizeof(time_T)*1);

41781
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

41782
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

41783
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

41784


41785
        /* Set up the mdlInfo pointer */

41786
# ifdef USE_RTMODEL

41787


41788
        {

41789
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

41790
              struct _ssBlkInfo2));

41791
          ss_VALIDATE_MEMORY(rts,blkInfo2);

41792
          ssSetBlkInfo2Ptr(childS, blkInfo2);

41793
        }

41794


41795
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

41796


41797
# else

41798


41799
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

41800


41801
# endif                                /* USE_RTMODEL */

41802


41803
        /* Allocate memory of model methods 2 */

41804
        {

41805
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

41806
            malloc(sizeof(struct _ssSFcnModelMethods2));

41807
          ss_VALIDATE_MEMORY(rts,methods2);

41808
          ssSetModelMethods2(childS, methods2);

41809
        }

41810


41811
        /* Allocate memory of model methods 3 */

41812
        {

41813
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

41814
            malloc(sizeof(struct _ssSFcnModelMethods3));

41815
          ss_VALIDATE_MEMORY(rts,methods3);

41816
          ssSetModelMethods3(childS, methods3);

41817
        }

41818


41819
        /* Allocate memory for states auxilliary information */

41820
        {

41821
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

41822
            (sizeof(struct _ssStatesInfo2));

41823
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

41824
            malloc(sizeof(ssPeriodicStatesInfo));

41825
          ss_VALIDATE_MEMORY(rts,statesInfo2);

41826
          ssSetStatesInfo2(childS, statesInfo2);

41827
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

41828
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

41829
        }

41830


41831
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

41832
          RegNumInputPorts);

41833
        ssSetRegNumInputPortsFcnArg(childS,childS);

41834


41835
        /* inputs */

41836
        {

41837
          struct _ssPortInputs *inputPortInfo =

41838
            (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));

41839
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

41840
          _ssSetNumInputPorts(childS, 5);

41841
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

41842


41843
          /* port 0 */

41844
          {

41845
            int8_T const **sfcnUPtrs = (int8_T const **)

41846
              malloc(1 * sizeof(int8_T *));

41847
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41848
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

41849
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

41850
            _ssSetInputPortNumDimensions(childS, 0, 1);

41851
            ssSetInputPortWidth(childS, 0, 1);

41852
          }

41853


41854
          /* port 1 */

41855
          {

41856
            real32_T const **sfcnUPtrs = (real32_T const **)

41857
              malloc(1 * sizeof(real32_T *));

41858
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41859
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

41860
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

41861
            _ssSetInputPortNumDimensions(childS, 1, 1);

41862
            ssSetInputPortWidth(childS, 1, 1);

41863
          }

41864


41865
          /* port 2 */

41866
          {

41867
            real32_T const **sfcnUPtrs = (real32_T const **)

41868
              malloc(1 * sizeof(real32_T *));

41869
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41870
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled133;

41871
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

41872
            _ssSetInputPortNumDimensions(childS, 2, 1);

41873
            ssSetInputPortWidth(childS, 2, 1);

41874
          }

41875


41876
          /* port 3 */

41877
          {

41878
            real32_T const **sfcnUPtrs = (real32_T const **)

41879
              malloc(1 * sizeof(real32_T *));

41880
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41881
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

41882
              ssGetLocalBlockIO(rts))->dtCAS;

41883
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

41884
            _ssSetInputPortNumDimensions(childS, 3, 1);

41885
            ssSetInputPortWidth(childS, 3, 1);

41886
          }

41887


41888
          /* port 4 */

41889
          {

41890
            real32_T const **sfcnUPtrs = (real32_T const **)

41891
              malloc(1 * sizeof(real32_T *));

41892
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

41893
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

41894
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_hf;

41895
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

41896
            _ssSetInputPortNumDimensions(childS, 4, 1);

41897
            ssSetInputPortWidth(childS, 4, 1);

41898
          }

41899
        }

41900


41901
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

41902
          RegNumOutputPorts);

41903
        ssSetRegNumOutputPortsFcnArg(childS,childS);

41904


41905
        /* outputs */

41906
        {

41907
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

41908
            calloc(2, sizeof(struct _ssPortOutputs));

41909
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

41910
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

41911
          _ssSetNumOutputPorts(childS, 2);

41912


41913
          /* port 0 */

41914
          {

41915
            _ssSetOutputPortNumDimensions(childS, 0, 1);

41916
            ssSetOutputPortWidth(childS, 0, 1);

41917
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

41918
              ssGetLocalBlockIO(rts))->Saturation9));

41919
          }

41920


41921
          /* port 1 */

41922
          {

41923
            _ssSetOutputPortNumDimensions(childS, 1, 1);

41924
            ssSetOutputPortWidth(childS, 1, 1);

41925
            _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)

41926
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_f));

41927
          }

41928
        }

41929


41930
        /* path info */

41931
        _ssSetModelName(childS, "RateLimiter_sf");

41932
        _ssSetPath(childS,

41933
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/sb/Rate Limiter1/Generated S-Function7");

41934
        if (ssGetRTModel(rts) == (NULL)) {

41935
          _ssSetParentSS(childS, rts);

41936
          _ssSetRootSS(childS, ssGetRootSS(rts));

41937
        } else {

41938
          ssSetRTModel(childS,ssGetRTModel(rts));

41939
          _ssSetParentSS(childS, (NULL));

41940
          _ssSetRootSS(childS, childS);

41941
        }

41942


41943
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

41944


41945
        /* work vectors */

41946
        {

41947
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

41948
            (3 * sizeof(struct _ssDWorkRecord));

41949
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

41950
            calloc(3, sizeof(struct _ssDWorkAuxRecord));

41951
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

41952
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

41953
          ssSetSFcnDWork(childS, dWorkRecord);

41954
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

41955
          _ssSetNumDWork(childS, 3);

41956


41957
          /* DWORK0 */

41958
          ssSetDWorkWidth(childS, 0, 1);

41959
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

41960
          ssSetDWorkComplexSignal(childS, 0, 0);

41961
          ssSetDWorkUsedAsDState(childS, 0, 1);

41962
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 266))[0]);

41963


41964
          /* DWORK1 */

41965
          ssSetDWorkWidth(childS, 1, 1);

41966
          ssSetDWorkDataType(childS, 1,SS_INT8);

41967
          ssSetDWorkComplexSignal(childS, 1, 0);

41968
          ssSetDWorkUsedAsDState(childS, 1, 1);

41969
          _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 496))[0]);

41970


41971
          /* DWORK2 */

41972
          ssSetDWorkWidth(childS, 2, 1);

41973
          ssSetDWorkDataType(childS, 2,SS_INT8);

41974
          ssSetDWorkComplexSignal(childS, 2, 0);

41975
          ssSetDWorkUsedAsDState(childS, 2, 1);

41976
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 497))[0]);

41977
        }

41978


41979
        (childS)->regDataType.arg1 = ((void *)(childS));

41980
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

41981
          FcnSetErrorStatus);

41982
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

41983
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

41984
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

41985
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

41986


41987
        /* registration */

41988
#if defined(MATLAB_MEX_FILE)

41989


41990
        {

41991
          int_T i;

41992
          mxArray *plhs[1];

41993
          mxArray *prhs[4];

41994
          double *pr;

41995
          volatile int_T *intS = (int_T *)&childS;

41996
          int_T addrlen = sizeof(SimStruct *);

41997
          int_T m = addrlen/sizeof(int_T) + 1;

41998
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

41999
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

42000
          pr = mxGetPr(prhs[1]);

42001
          for (i = 0; i < m - 1; i++) {

42002
            pr[i] = (double)intS[i];

42003
          }

42004


42005
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

42006
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

42007
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

42008


42009
          /* Reset port dimensions info functions because the S-function

42010
           * and accelerator mex-files explicitly set their dimensions,

42011
           * i.e., they are not dynamically sized. For this case, the

42012
           * mex-file is responsible for the dimensions info memory

42013
           * and Simulink should not free it. This is achieved by

42014
           * setting the following two methods to NULL.

42015
           */

42016
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

42017
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

42018


42019
          /*

42020
           * Setup function pointers and call mdlInitializeSizes via

42021
           * simulink.c

42022
           */

42023
          mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");

42024
          mxDestroyArray(plhs[0]);

42025
          mxDestroyArray(prhs[0]);

42026
          mxDestroyArray(prhs[1]);

42027
          mxDestroyArray(prhs[2]);

42028
          mxDestroyArray(prhs[3]);

42029
        }

42030


42031
#else

42032


42033
        {

42034
          RateLimiter_sf(childS);

42035
          sfcnInitializeSizes(childS);

42036
        }

42037


42038
#endif

42039


42040
        sfcnInitializeSampleTimes(childS);

42041


42042
        /* adjust sample time */

42043
        ssSetSampleTime(childS, 0, 0.0);

42044
        ssSetOffsetTime(childS, 0, 0.0);

42045
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

42046


42047
        /* set compiled values of dynamic vector attributes */

42048
        ssSetNumNonsampledZCs(childS, 0);

42049


42050
        /* Update connectivity flags for each port */

42051
        _ssSetInputPortConnected(childS, 0, 1);

42052
        _ssSetInputPortConnected(childS, 1, 1);

42053
        _ssSetInputPortConnected(childS, 2, 1);

42054
        _ssSetInputPortConnected(childS, 3, 1);

42055
        _ssSetInputPortConnected(childS, 4, 1);

42056
        _ssSetOutputPortConnected(childS, 0, 1);

42057
        _ssSetOutputPortConnected(childS, 1, 1);

42058
        _ssSetOutputPortBeingMerged(childS, 0, 0);

42059
        _ssSetOutputPortBeingMerged(childS, 1, 0);

42060


42061
        /* Update the BufferDstPort flags for each input port */

42062
        _ssSetInputPortBufferDstPort(childS, 0, -1);

42063
        _ssSetInputPortBufferDstPort(childS, 1, -1);

42064
        _ssSetInputPortBufferDstPort(childS, 2, -1);

42065
        _ssSetInputPortBufferDstPort(childS, 3, -1);

42066
        _ssSetInputPortBufferDstPort(childS, 4, -1);

42067
      }

42068


42069
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S215>/Generated S-Function4 (LagFilter_sf) */

42070
      {

42071
        SimStruct *childS = ssGetSFunction(rts, 160);

42072


42073
        /* timing info */

42074
        time_T *sfcnPeriod;

42075
        time_T *sfcnOffset;

42076
        int_T *sfcnTsMap;

42077
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

42078
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

42079
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

42080
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

42081
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

42082
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

42083
        (void) memset((void*)sfcnPeriod, 0,

42084
                      sizeof(time_T)*1);

42085
        (void) memset((void*)sfcnOffset, 0,

42086
                      sizeof(time_T)*1);

42087
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

42088
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

42089
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

42090


42091
        /* Set up the mdlInfo pointer */

42092
# ifdef USE_RTMODEL

42093


42094
        {

42095
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

42096
              struct _ssBlkInfo2));

42097
          ss_VALIDATE_MEMORY(rts,blkInfo2);

42098
          ssSetBlkInfo2Ptr(childS, blkInfo2);

42099
        }

42100


42101
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

42102


42103
# else

42104


42105
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

42106


42107
# endif                                /* USE_RTMODEL */

42108


42109
        /* Allocate memory of model methods 2 */

42110
        {

42111
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

42112
            malloc(sizeof(struct _ssSFcnModelMethods2));

42113
          ss_VALIDATE_MEMORY(rts,methods2);

42114
          ssSetModelMethods2(childS, methods2);

42115
        }

42116


42117
        /* Allocate memory of model methods 3 */

42118
        {

42119
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

42120
            malloc(sizeof(struct _ssSFcnModelMethods3));

42121
          ss_VALIDATE_MEMORY(rts,methods3);

42122
          ssSetModelMethods3(childS, methods3);

42123
        }

42124


42125
        /* Allocate memory for states auxilliary information */

42126
        {

42127
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

42128
            (sizeof(struct _ssStatesInfo2));

42129
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

42130
            malloc(sizeof(ssPeriodicStatesInfo));

42131
          ss_VALIDATE_MEMORY(rts,statesInfo2);

42132
          ssSetStatesInfo2(childS, statesInfo2);

42133
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

42134
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

42135
        }

42136


42137
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

42138
          RegNumInputPorts);

42139
        ssSetRegNumInputPortsFcnArg(childS,childS);

42140


42141
        /* inputs */

42142
        {

42143
          struct _ssPortInputs *inputPortInfo =

42144
            (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));

42145
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

42146
          _ssSetNumInputPorts(childS, 6);

42147
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

42148


42149
          /* port 0 */

42150
          {

42151
            real32_T const **sfcnUPtrs = (real32_T const **)

42152
              malloc(1 * sizeof(real32_T *));

42153
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42154
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42155
              ssGetLocalBlockIO(rts))->dtCAS;

42156
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

42157
            _ssSetInputPortNumDimensions(childS, 0, 1);

42158
            ssSetInputPortWidth(childS, 0, 1);

42159
          }

42160


42161
          /* port 1 */

42162
          {

42163
            int8_T const **sfcnUPtrs = (int8_T const **)

42164
              malloc(1 * sizeof(int8_T *));

42165
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42166
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

42167
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

42168
            _ssSetInputPortNumDimensions(childS, 1, 1);

42169
            ssSetInputPortWidth(childS, 1, 1);

42170
          }

42171


42172
          /* port 2 */

42173
          {

42174
            real32_T const **sfcnUPtrs = (real32_T const **)

42175
              malloc(1 * sizeof(real32_T *));

42176
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42177
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled126;

42178
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

42179
            _ssSetInputPortNumDimensions(childS, 2, 1);

42180
            ssSetInputPortWidth(childS, 2, 1);

42181
          }

42182


42183
          /* port 3 */

42184
          {

42185
            real32_T const **sfcnUPtrs = (real32_T const **)

42186
              malloc(1 * sizeof(real32_T *));

42187
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42188
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42189
              ssGetLocalBlockIO(rts))->Saturation1_o;

42190
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

42191
            _ssSetInputPortNumDimensions(childS, 3, 1);

42192
            ssSetInputPortWidth(childS, 3, 1);

42193
          }

42194


42195
          /* port 4 */

42196
          {

42197
            real32_T const **sfcnUPtrs = (real32_T const **)

42198
              malloc(1 * sizeof(real32_T *));

42199
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42200
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42201
              ssGetLocalBlockIO(rts))->Saturation1_o;

42202
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

42203
            _ssSetInputPortNumDimensions(childS, 4, 1);

42204
            ssSetInputPortWidth(childS, 4, 1);

42205
          }

42206


42207
          /* port 5 */

42208
          {

42209
            real32_T const **sfcnUPtrs = (real32_T const **)

42210
              malloc(1 * sizeof(real32_T *));

42211
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42212
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42213
              ssGetLocalBlockIO(rts))->Saturation_p;

42214
            _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);

42215
            _ssSetInputPortNumDimensions(childS, 5, 1);

42216
            ssSetInputPortWidth(childS, 5, 1);

42217
          }

42218
        }

42219


42220
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

42221
          RegNumOutputPorts);

42222
        ssSetRegNumOutputPortsFcnArg(childS,childS);

42223


42224
        /* outputs */

42225
        {

42226
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

42227
            calloc(1, sizeof(struct _ssPortOutputs));

42228
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

42229
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

42230
          _ssSetNumOutputPorts(childS, 1);

42231


42232
          /* port 0 */

42233
          {

42234
            _ssSetOutputPortNumDimensions(childS, 0, 1);

42235
            ssSetOutputPortWidth(childS, 0, 1);

42236
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

42237
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));

42238
          }

42239
        }

42240


42241
        /* path info */

42242
        _ssSetModelName(childS, "LagFilter_sf");

42243
        _ssSetPath(childS,

42244
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/ lag filter2/Generated S-Function4");

42245
        if (ssGetRTModel(rts) == (NULL)) {

42246
          _ssSetParentSS(childS, rts);

42247
          _ssSetRootSS(childS, ssGetRootSS(rts));

42248
        } else {

42249
          ssSetRTModel(childS,ssGetRTModel(rts));

42250
          _ssSetParentSS(childS, (NULL));

42251
          _ssSetRootSS(childS, childS);

42252
        }

42253


42254
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

42255


42256
        /* work vectors */

42257
        {

42258
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

42259
            (4 * sizeof(struct _ssDWorkRecord));

42260
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

42261
            calloc(4, sizeof(struct _ssDWorkAuxRecord));

42262
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

42263
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

42264
          ssSetSFcnDWork(childS, dWorkRecord);

42265
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

42266
          _ssSetNumDWork(childS, 4);

42267


42268
          /* DWORK0 */

42269
          ssSetDWorkWidth(childS, 0, 1);

42270
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

42271
          ssSetDWorkComplexSignal(childS, 0, 0);

42272
          ssSetDWorkUsedAsDState(childS, 0, 1);

42273
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 267))[0]);

42274


42275
          /* DWORK1 */

42276
          ssSetDWorkWidth(childS, 1, 1);

42277
          ssSetDWorkDataType(childS, 1,SS_SINGLE);

42278
          ssSetDWorkComplexSignal(childS, 1, 0);

42279
          ssSetDWorkUsedAsDState(childS, 1, 1);

42280
          _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 268))[0]);

42281


42282
          /* DWORK2 */

42283
          ssSetDWorkWidth(childS, 2, 1);

42284
          ssSetDWorkDataType(childS, 2,SS_INT8);

42285
          ssSetDWorkComplexSignal(childS, 2, 0);

42286
          ssSetDWorkUsedAsDState(childS, 2, 1);

42287
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 498))[0]);

42288


42289
          /* DWORK3 */

42290
          ssSetDWorkWidth(childS, 3, 1);

42291
          ssSetDWorkDataType(childS, 3,SS_INT8);

42292
          ssSetDWorkComplexSignal(childS, 3, 0);

42293
          ssSetDWorkUsedAsDState(childS, 3, 1);

42294
          _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 499))[0]);

42295
        }

42296


42297
        (childS)->regDataType.arg1 = ((void *)(childS));

42298
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

42299
          FcnSetErrorStatus);

42300
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

42301
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

42302
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

42303
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

42304


42305
        /* registration */

42306
#if defined(MATLAB_MEX_FILE)

42307


42308
        {

42309
          int_T i;

42310
          mxArray *plhs[1];

42311
          mxArray *prhs[4];

42312
          double *pr;

42313
          volatile int_T *intS = (int_T *)&childS;

42314
          int_T addrlen = sizeof(SimStruct *);

42315
          int_T m = addrlen/sizeof(int_T) + 1;

42316
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

42317
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

42318
          pr = mxGetPr(prhs[1]);

42319
          for (i = 0; i < m - 1; i++) {

42320
            pr[i] = (double)intS[i];

42321
          }

42322


42323
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

42324
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

42325
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

42326


42327
          /* Reset port dimensions info functions because the S-function

42328
           * and accelerator mex-files explicitly set their dimensions,

42329
           * i.e., they are not dynamically sized. For this case, the

42330
           * mex-file is responsible for the dimensions info memory

42331
           * and Simulink should not free it. This is achieved by

42332
           * setting the following two methods to NULL.

42333
           */

42334
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

42335
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

42336


42337
          /*

42338
           * Setup function pointers and call mdlInitializeSizes via

42339
           * simulink.c

42340
           */

42341
          mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");

42342
          mxDestroyArray(plhs[0]);

42343
          mxDestroyArray(prhs[0]);

42344
          mxDestroyArray(prhs[1]);

42345
          mxDestroyArray(prhs[2]);

42346
          mxDestroyArray(prhs[3]);

42347
        }

42348


42349
#else

42350


42351
        {

42352
          LagFilter_sf(childS);

42353
          sfcnInitializeSizes(childS);

42354
        }

42355


42356
#endif

42357


42358
        sfcnInitializeSampleTimes(childS);

42359


42360
        /* adjust sample time */

42361
        ssSetSampleTime(childS, 0, 0.0);

42362
        ssSetOffsetTime(childS, 0, 0.0);

42363
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

42364


42365
        /* set compiled values of dynamic vector attributes */

42366
        ssSetNumNonsampledZCs(childS, 0);

42367


42368
        /* Update connectivity flags for each port */

42369
        _ssSetInputPortConnected(childS, 0, 1);

42370
        _ssSetInputPortConnected(childS, 1, 1);

42371
        _ssSetInputPortConnected(childS, 2, 1);

42372
        _ssSetInputPortConnected(childS, 3, 1);

42373
        _ssSetInputPortConnected(childS, 4, 1);

42374
        _ssSetInputPortConnected(childS, 5, 1);

42375
        _ssSetOutputPortConnected(childS, 0, 1);

42376
        _ssSetOutputPortBeingMerged(childS, 0, 0);

42377


42378
        /* Update the BufferDstPort flags for each input port */

42379
        _ssSetInputPortBufferDstPort(childS, 0, -1);

42380
        _ssSetInputPortBufferDstPort(childS, 1, -1);

42381
        _ssSetInputPortBufferDstPort(childS, 2, -1);

42382
        _ssSetInputPortBufferDstPort(childS, 3, -1);

42383
        _ssSetInputPortBufferDstPort(childS, 4, -1);

42384
        _ssSetInputPortBufferDstPort(childS, 5, -1);

42385
      }

42386


42387
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S218>/Generated S-Function (Gain_sf) */

42388
      {

42389
        SimStruct *childS = ssGetSFunction(rts, 161);

42390


42391
        /* timing info */

42392
        time_T *sfcnPeriod;

42393
        time_T *sfcnOffset;

42394
        int_T *sfcnTsMap;

42395
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

42396
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

42397
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

42398
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

42399
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

42400
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

42401
        (void) memset((void*)sfcnPeriod, 0,

42402
                      sizeof(time_T)*1);

42403
        (void) memset((void*)sfcnOffset, 0,

42404
                      sizeof(time_T)*1);

42405
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

42406
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

42407
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

42408


42409
        /* Set up the mdlInfo pointer */

42410
# ifdef USE_RTMODEL

42411


42412
        {

42413
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

42414
              struct _ssBlkInfo2));

42415
          ss_VALIDATE_MEMORY(rts,blkInfo2);

42416
          ssSetBlkInfo2Ptr(childS, blkInfo2);

42417
        }

42418


42419
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

42420


42421
# else

42422


42423
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

42424


42425
# endif                                /* USE_RTMODEL */

42426


42427
        /* Allocate memory of model methods 2 */

42428
        {

42429
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

42430
            malloc(sizeof(struct _ssSFcnModelMethods2));

42431
          ss_VALIDATE_MEMORY(rts,methods2);

42432
          ssSetModelMethods2(childS, methods2);

42433
        }

42434


42435
        /* Allocate memory of model methods 3 */

42436
        {

42437
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

42438
            malloc(sizeof(struct _ssSFcnModelMethods3));

42439
          ss_VALIDATE_MEMORY(rts,methods3);

42440
          ssSetModelMethods3(childS, methods3);

42441
        }

42442


42443
        /* Allocate memory for states auxilliary information */

42444
        {

42445
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

42446
            (sizeof(struct _ssStatesInfo2));

42447
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

42448
            malloc(sizeof(ssPeriodicStatesInfo));

42449
          ss_VALIDATE_MEMORY(rts,statesInfo2);

42450
          ssSetStatesInfo2(childS, statesInfo2);

42451
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

42452
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

42453
        }

42454


42455
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

42456
          RegNumInputPorts);

42457
        ssSetRegNumInputPortsFcnArg(childS,childS);

42458


42459
        /* inputs */

42460
        {

42461
          struct _ssPortInputs *inputPortInfo =

42462
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

42463
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

42464
          _ssSetNumInputPorts(childS, 2);

42465
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

42466


42467
          /* port 0 */

42468
          {

42469
            real32_T const **sfcnUPtrs = (real32_T const **)

42470
              malloc(1 * sizeof(real32_T *));

42471
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42472
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42473
              ssGetLocalBlockIO(rts))->Sum_b;

42474
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

42475
            _ssSetInputPortNumDimensions(childS, 0, 1);

42476
            ssSetInputPortWidth(childS, 0, 1);

42477
          }

42478


42479
          /* port 1 */

42480
          {

42481
            real32_T const **sfcnUPtrs = (real32_T const **)

42482
              malloc(1 * sizeof(real32_T *));

42483
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42484
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled133;

42485
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

42486
            _ssSetInputPortNumDimensions(childS, 1, 1);

42487
            ssSetInputPortWidth(childS, 1, 1);

42488
          }

42489
        }

42490


42491
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

42492
          RegNumOutputPorts);

42493
        ssSetRegNumOutputPortsFcnArg(childS,childS);

42494


42495
        /* outputs */

42496
        {

42497
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

42498
            calloc(1, sizeof(struct _ssPortOutputs));

42499
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

42500
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

42501
          _ssSetNumOutputPorts(childS, 1);

42502


42503
          /* port 0 */

42504
          {

42505
            _ssSetOutputPortNumDimensions(childS, 0, 1);

42506
            ssSetOutputPortWidth(childS, 0, 1);

42507
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

42508
              ssGetLocalBlockIO(rts))->GeneratedSFunction_ka));

42509
          }

42510
        }

42511


42512
        /* path info */

42513
        _ssSetModelName(childS, "Gain_sf");

42514
        _ssSetPath(childS,

42515
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/gain3/Generated S-Function");

42516
        if (ssGetRTModel(rts) == (NULL)) {

42517
          _ssSetParentSS(childS, rts);

42518
          _ssSetRootSS(childS, ssGetRootSS(rts));

42519
        } else {

42520
          ssSetRTModel(childS,ssGetRTModel(rts));

42521
          _ssSetParentSS(childS, (NULL));

42522
          _ssSetRootSS(childS, childS);

42523
        }

42524


42525
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

42526
        (childS)->regDataType.arg1 = ((void *)(childS));

42527
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

42528
          FcnSetErrorStatus);

42529
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

42530
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

42531
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

42532
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

42533


42534
        /* registration */

42535
#if defined(MATLAB_MEX_FILE)

42536


42537
        {

42538
          int_T i;

42539
          mxArray *plhs[1];

42540
          mxArray *prhs[4];

42541
          double *pr;

42542
          volatile int_T *intS = (int_T *)&childS;

42543
          int_T addrlen = sizeof(SimStruct *);

42544
          int_T m = addrlen/sizeof(int_T) + 1;

42545
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

42546
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

42547
          pr = mxGetPr(prhs[1]);

42548
          for (i = 0; i < m - 1; i++) {

42549
            pr[i] = (double)intS[i];

42550
          }

42551


42552
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

42553
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

42554
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

42555


42556
          /* Reset port dimensions info functions because the S-function

42557
           * and accelerator mex-files explicitly set their dimensions,

42558
           * i.e., they are not dynamically sized. For this case, the

42559
           * mex-file is responsible for the dimensions info memory

42560
           * and Simulink should not free it. This is achieved by

42561
           * setting the following two methods to NULL.

42562
           */

42563
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

42564
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

42565


42566
          /*

42567
           * Setup function pointers and call mdlInitializeSizes via

42568
           * simulink.c

42569
           */

42570
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

42571
          mxDestroyArray(plhs[0]);

42572
          mxDestroyArray(prhs[0]);

42573
          mxDestroyArray(prhs[1]);

42574
          mxDestroyArray(prhs[2]);

42575
          mxDestroyArray(prhs[3]);

42576
        }

42577


42578
#else

42579


42580
        {

42581
          Gain_sf(childS);

42582
          sfcnInitializeSizes(childS);

42583
        }

42584


42585
#endif

42586


42587
        sfcnInitializeSampleTimes(childS);

42588


42589
        /* adjust sample time */

42590
        ssSetSampleTime(childS, 0, 0.0);

42591
        ssSetOffsetTime(childS, 0, 0.0);

42592
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

42593


42594
        /* set compiled values of dynamic vector attributes */

42595
        ssSetNumNonsampledZCs(childS, 0);

42596


42597
        /* Update connectivity flags for each port */

42598
        _ssSetInputPortConnected(childS, 0, 1);

42599
        _ssSetInputPortConnected(childS, 1, 1);

42600
        _ssSetOutputPortConnected(childS, 0, 1);

42601
        _ssSetOutputPortBeingMerged(childS, 0, 0);

42602


42603
        /* Update the BufferDstPort flags for each input port */

42604
        _ssSetInputPortBufferDstPort(childS, 0, -1);

42605
        _ssSetInputPortBufferDstPort(childS, 1, -1);

42606
      }

42607


42608
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S217>/Generated S-Function1 (SaturationLimiter_sf) */

42609
      {

42610
        SimStruct *childS = ssGetSFunction(rts, 162);

42611


42612
        /* timing info */

42613
        time_T *sfcnPeriod;

42614
        time_T *sfcnOffset;

42615
        int_T *sfcnTsMap;

42616
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

42617
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

42618
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

42619
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

42620
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

42621
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

42622
        (void) memset((void*)sfcnPeriod, 0,

42623
                      sizeof(time_T)*1);

42624
        (void) memset((void*)sfcnOffset, 0,

42625
                      sizeof(time_T)*1);

42626
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

42627
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

42628
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

42629


42630
        /* Set up the mdlInfo pointer */

42631
# ifdef USE_RTMODEL

42632


42633
        {

42634
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

42635
              struct _ssBlkInfo2));

42636
          ss_VALIDATE_MEMORY(rts,blkInfo2);

42637
          ssSetBlkInfo2Ptr(childS, blkInfo2);

42638
        }

42639


42640
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

42641


42642
# else

42643


42644
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

42645


42646
# endif                                /* USE_RTMODEL */

42647


42648
        /* Allocate memory of model methods 2 */

42649
        {

42650
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

42651
            malloc(sizeof(struct _ssSFcnModelMethods2));

42652
          ss_VALIDATE_MEMORY(rts,methods2);

42653
          ssSetModelMethods2(childS, methods2);

42654
        }

42655


42656
        /* Allocate memory of model methods 3 */

42657
        {

42658
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

42659
            malloc(sizeof(struct _ssSFcnModelMethods3));

42660
          ss_VALIDATE_MEMORY(rts,methods3);

42661
          ssSetModelMethods3(childS, methods3);

42662
        }

42663


42664
        /* Allocate memory for states auxilliary information */

42665
        {

42666
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

42667
            (sizeof(struct _ssStatesInfo2));

42668
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

42669
            malloc(sizeof(ssPeriodicStatesInfo));

42670
          ss_VALIDATE_MEMORY(rts,statesInfo2);

42671
          ssSetStatesInfo2(childS, statesInfo2);

42672
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

42673
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

42674
        }

42675


42676
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

42677
          RegNumInputPorts);

42678
        ssSetRegNumInputPortsFcnArg(childS,childS);

42679


42680
        /* inputs */

42681
        {

42682
          struct _ssPortInputs *inputPortInfo =

42683
            (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));

42684
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

42685
          _ssSetNumInputPorts(childS, 3);

42686
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

42687


42688
          /* port 0 */

42689
          {

42690
            real32_T const **sfcnUPtrs = (real32_T const **)

42691
              malloc(1 * sizeof(real32_T *));

42692
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42693
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42694
              ssGetLocalBlockIO(rts))->Switch_bw;

42695
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

42696
            _ssSetInputPortNumDimensions(childS, 0, 1);

42697
            ssSetInputPortWidth(childS, 0, 1);

42698
          }

42699


42700
          /* port 1 */

42701
          {

42702
            real32_T const **sfcnUPtrs = (real32_T const **)

42703
              malloc(1 * sizeof(real32_T *));

42704
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42705
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42706
              ssGetLocalBlockIO(rts))->Product4_o;

42707
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

42708
            _ssSetInputPortNumDimensions(childS, 1, 1);

42709
            ssSetInputPortWidth(childS, 1, 1);

42710
          }

42711


42712
          /* port 2 */

42713
          {

42714
            real32_T const **sfcnUPtrs = (real32_T const **)

42715
              malloc(1 * sizeof(real32_T *));

42716
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42717
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42718
              ssGetLocalBlockIO(rts))->Product3_d;

42719
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

42720
            _ssSetInputPortNumDimensions(childS, 2, 1);

42721
            ssSetInputPortWidth(childS, 2, 1);

42722
          }

42723
        }

42724


42725
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

42726
          RegNumOutputPorts);

42727
        ssSetRegNumOutputPortsFcnArg(childS,childS);

42728


42729
        /* outputs */

42730
        {

42731
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

42732
            calloc(1, sizeof(struct _ssPortOutputs));

42733
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

42734
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

42735
          _ssSetNumOutputPorts(childS, 1);

42736


42737
          /* port 0 */

42738
          {

42739
            _ssSetOutputPortNumDimensions(childS, 0, 1);

42740
            ssSetOutputPortWidth(childS, 0, 1);

42741
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

42742
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_hx));

42743
          }

42744
        }

42745


42746
        /* path info */

42747
        _ssSetModelName(childS, "SaturationLimiter_sf");

42748
        _ssSetPath(childS,

42749
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/Saturation Limiter1/Generated S-Function1");

42750
        if (ssGetRTModel(rts) == (NULL)) {

42751
          _ssSetParentSS(childS, rts);

42752
          _ssSetRootSS(childS, ssGetRootSS(rts));

42753
        } else {

42754
          ssSetRTModel(childS,ssGetRTModel(rts));

42755
          _ssSetParentSS(childS, (NULL));

42756
          _ssSetRootSS(childS, childS);

42757
        }

42758


42759
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

42760
        (childS)->regDataType.arg1 = ((void *)(childS));

42761
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

42762
          FcnSetErrorStatus);

42763
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

42764
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

42765
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

42766
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

42767


42768
        /* registration */

42769
#if defined(MATLAB_MEX_FILE)

42770


42771
        {

42772
          int_T i;

42773
          mxArray *plhs[1];

42774
          mxArray *prhs[4];

42775
          double *pr;

42776
          volatile int_T *intS = (int_T *)&childS;

42777
          int_T addrlen = sizeof(SimStruct *);

42778
          int_T m = addrlen/sizeof(int_T) + 1;

42779
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

42780
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

42781
          pr = mxGetPr(prhs[1]);

42782
          for (i = 0; i < m - 1; i++) {

42783
            pr[i] = (double)intS[i];

42784
          }

42785


42786
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

42787
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

42788
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

42789


42790
          /* Reset port dimensions info functions because the S-function

42791
           * and accelerator mex-files explicitly set their dimensions,

42792
           * i.e., they are not dynamically sized. For this case, the

42793
           * mex-file is responsible for the dimensions info memory

42794
           * and Simulink should not free it. This is achieved by

42795
           * setting the following two methods to NULL.

42796
           */

42797
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

42798
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

42799


42800
          /*

42801
           * Setup function pointers and call mdlInitializeSizes via

42802
           * simulink.c

42803
           */

42804
          mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");

42805
          mxDestroyArray(plhs[0]);

42806
          mxDestroyArray(prhs[0]);

42807
          mxDestroyArray(prhs[1]);

42808
          mxDestroyArray(prhs[2]);

42809
          mxDestroyArray(prhs[3]);

42810
        }

42811


42812
#else

42813


42814
        {

42815
          SaturationLimiter_sf(childS);

42816
          sfcnInitializeSizes(childS);

42817
        }

42818


42819
#endif

42820


42821
        sfcnInitializeSampleTimes(childS);

42822


42823
        /* adjust sample time */

42824
        ssSetSampleTime(childS, 0, 0.0);

42825
        ssSetOffsetTime(childS, 0, 0.0);

42826
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

42827


42828
        /* set compiled values of dynamic vector attributes */

42829
        ssSetNumNonsampledZCs(childS, 0);

42830


42831
        /* Update connectivity flags for each port */

42832
        _ssSetInputPortConnected(childS, 0, 1);

42833
        _ssSetInputPortConnected(childS, 1, 1);

42834
        _ssSetInputPortConnected(childS, 2, 1);

42835
        _ssSetOutputPortConnected(childS, 0, 1);

42836
        _ssSetOutputPortBeingMerged(childS, 0, 0);

42837


42838
        /* Update the BufferDstPort flags for each input port */

42839
        _ssSetInputPortBufferDstPort(childS, 0, -1);

42840
        _ssSetInputPortBufferDstPort(childS, 1, -1);

42841
        _ssSetInputPortBufferDstPort(childS, 2, -1);

42842
      }

42843


42844
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S216>/Generated S-Function7 (RateLimiter_sf) */

42845
      {

42846
        SimStruct *childS = ssGetSFunction(rts, 163);

42847


42848
        /* timing info */

42849
        time_T *sfcnPeriod;

42850
        time_T *sfcnOffset;

42851
        int_T *sfcnTsMap;

42852
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

42853
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

42854
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

42855
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

42856
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

42857
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

42858
        (void) memset((void*)sfcnPeriod, 0,

42859
                      sizeof(time_T)*1);

42860
        (void) memset((void*)sfcnOffset, 0,

42861
                      sizeof(time_T)*1);

42862
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

42863
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

42864
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

42865


42866
        /* Set up the mdlInfo pointer */

42867
# ifdef USE_RTMODEL

42868


42869
        {

42870
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

42871
              struct _ssBlkInfo2));

42872
          ss_VALIDATE_MEMORY(rts,blkInfo2);

42873
          ssSetBlkInfo2Ptr(childS, blkInfo2);

42874
        }

42875


42876
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

42877


42878
# else

42879


42880
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

42881


42882
# endif                                /* USE_RTMODEL */

42883


42884
        /* Allocate memory of model methods 2 */

42885
        {

42886
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

42887
            malloc(sizeof(struct _ssSFcnModelMethods2));

42888
          ss_VALIDATE_MEMORY(rts,methods2);

42889
          ssSetModelMethods2(childS, methods2);

42890
        }

42891


42892
        /* Allocate memory of model methods 3 */

42893
        {

42894
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

42895
            malloc(sizeof(struct _ssSFcnModelMethods3));

42896
          ss_VALIDATE_MEMORY(rts,methods3);

42897
          ssSetModelMethods3(childS, methods3);

42898
        }

42899


42900
        /* Allocate memory for states auxilliary information */

42901
        {

42902
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

42903
            (sizeof(struct _ssStatesInfo2));

42904
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

42905
            malloc(sizeof(ssPeriodicStatesInfo));

42906
          ss_VALIDATE_MEMORY(rts,statesInfo2);

42907
          ssSetStatesInfo2(childS, statesInfo2);

42908
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

42909
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

42910
        }

42911


42912
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

42913
          RegNumInputPorts);

42914
        ssSetRegNumInputPortsFcnArg(childS,childS);

42915


42916
        /* inputs */

42917
        {

42918
          struct _ssPortInputs *inputPortInfo =

42919
            (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));

42920
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

42921
          _ssSetNumInputPorts(childS, 5);

42922
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

42923


42924
          /* port 0 */

42925
          {

42926
            int8_T const **sfcnUPtrs = (int8_T const **)

42927
              malloc(1 * sizeof(int8_T *));

42928
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42929
            sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;

42930
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

42931
            _ssSetInputPortNumDimensions(childS, 0, 1);

42932
            ssSetInputPortWidth(childS, 0, 1);

42933
          }

42934


42935
          /* port 1 */

42936
          {

42937
            real32_T const **sfcnUPtrs = (real32_T const **)

42938
              malloc(1 * sizeof(real32_T *));

42939
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42940
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;

42941
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

42942
            _ssSetInputPortNumDimensions(childS, 1, 1);

42943
            ssSetInputPortWidth(childS, 1, 1);

42944
          }

42945


42946
          /* port 2 */

42947
          {

42948
            real32_T const **sfcnUPtrs = (real32_T const **)

42949
              malloc(1 * sizeof(real32_T *));

42950
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42951
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled134;

42952
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

42953
            _ssSetInputPortNumDimensions(childS, 2, 1);

42954
            ssSetInputPortWidth(childS, 2, 1);

42955
          }

42956


42957
          /* port 3 */

42958
          {

42959
            real32_T const **sfcnUPtrs = (real32_T const **)

42960
              malloc(1 * sizeof(real32_T *));

42961
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42962
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42963
              ssGetLocalBlockIO(rts))->dtCAS;

42964
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

42965
            _ssSetInputPortNumDimensions(childS, 3, 1);

42966
            ssSetInputPortWidth(childS, 3, 1);

42967
          }

42968


42969
          /* port 4 */

42970
          {

42971
            real32_T const **sfcnUPtrs = (real32_T const **)

42972
              malloc(1 * sizeof(real32_T *));

42973
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

42974
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

42975
              ssGetLocalBlockIO(rts))->GeneratedSFunction1_hx;

42976
            _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);

42977
            _ssSetInputPortNumDimensions(childS, 4, 1);

42978
            ssSetInputPortWidth(childS, 4, 1);

42979
          }

42980
        }

42981


42982
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

42983
          RegNumOutputPorts);

42984
        ssSetRegNumOutputPortsFcnArg(childS,childS);

42985


42986
        /* outputs */

42987
        {

42988
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

42989
            calloc(2, sizeof(struct _ssPortOutputs));

42990
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

42991
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

42992
          _ssSetNumOutputPorts(childS, 2);

42993


42994
          /* port 0 */

42995
          {

42996
            _ssSetOutputPortNumDimensions(childS, 0, 1);

42997
            ssSetOutputPortWidth(childS, 0, 1);

42998
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

42999
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));

43000
          }

43001


43002
          /* port 1 */

43003
          {

43004
            _ssSetOutputPortNumDimensions(childS, 1, 1);

43005
            ssSetOutputPortWidth(childS, 1, 1);

43006
            _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)

43007
              ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_k));

43008
          }

43009
        }

43010


43011
        /* path info */

43012
        _ssSetModelName(childS, "RateLimiter_sf");

43013
        _ssSetPath(childS,

43014
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/Rate Limiter1/Generated S-Function7");

43015
        if (ssGetRTModel(rts) == (NULL)) {

43016
          _ssSetParentSS(childS, rts);

43017
          _ssSetRootSS(childS, ssGetRootSS(rts));

43018
        } else {

43019
          ssSetRTModel(childS,ssGetRTModel(rts));

43020
          _ssSetParentSS(childS, (NULL));

43021
          _ssSetRootSS(childS, childS);

43022
        }

43023


43024
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

43025


43026
        /* work vectors */

43027
        {

43028
          struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc

43029
            (3 * sizeof(struct _ssDWorkRecord));

43030
          struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

43031
            calloc(3, sizeof(struct _ssDWorkAuxRecord));

43032
          ss_VALIDATE_MEMORY(rts,dWorkRecord);

43033
          ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);

43034
          ssSetSFcnDWork(childS, dWorkRecord);

43035
          ssSetSFcnDWorkAux(childS, dWorkAuxRecord);

43036
          _ssSetNumDWork(childS, 3);

43037


43038
          /* DWORK0 */

43039
          ssSetDWorkWidth(childS, 0, 1);

43040
          ssSetDWorkDataType(childS, 0,SS_SINGLE);

43041
          ssSetDWorkComplexSignal(childS, 0, 0);

43042
          ssSetDWorkUsedAsDState(childS, 0, 1);

43043
          _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 269))[0]);

43044


43045
          /* DWORK1 */

43046
          ssSetDWorkWidth(childS, 1, 1);

43047
          ssSetDWorkDataType(childS, 1,SS_INT8);

43048
          ssSetDWorkComplexSignal(childS, 1, 0);

43049
          ssSetDWorkUsedAsDState(childS, 1, 1);

43050
          _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 500))[0]);

43051


43052
          /* DWORK2 */

43053
          ssSetDWorkWidth(childS, 2, 1);

43054
          ssSetDWorkDataType(childS, 2,SS_INT8);

43055
          ssSetDWorkComplexSignal(childS, 2, 0);

43056
          ssSetDWorkUsedAsDState(childS, 2, 1);

43057
          _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 501))[0]);

43058
        }

43059


43060
        (childS)->regDataType.arg1 = ((void *)(childS));

43061
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

43062
          FcnSetErrorStatus);

43063
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

43064
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

43065
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

43066
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

43067


43068
        /* registration */

43069
#if defined(MATLAB_MEX_FILE)

43070


43071
        {

43072
          int_T i;

43073
          mxArray *plhs[1];

43074
          mxArray *prhs[4];

43075
          double *pr;

43076
          volatile int_T *intS = (int_T *)&childS;

43077
          int_T addrlen = sizeof(SimStruct *);

43078
          int_T m = addrlen/sizeof(int_T) + 1;

43079
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

43080
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

43081
          pr = mxGetPr(prhs[1]);

43082
          for (i = 0; i < m - 1; i++) {

43083
            pr[i] = (double)intS[i];

43084
          }

43085


43086
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

43087
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

43088
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

43089


43090
          /* Reset port dimensions info functions because the S-function

43091
           * and accelerator mex-files explicitly set their dimensions,

43092
           * i.e., they are not dynamically sized. For this case, the

43093
           * mex-file is responsible for the dimensions info memory

43094
           * and Simulink should not free it. This is achieved by

43095
           * setting the following two methods to NULL.

43096
           */

43097
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

43098
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

43099


43100
          /*

43101
           * Setup function pointers and call mdlInitializeSizes via

43102
           * simulink.c

43103
           */

43104
          mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");

43105
          mxDestroyArray(plhs[0]);

43106
          mxDestroyArray(prhs[0]);

43107
          mxDestroyArray(prhs[1]);

43108
          mxDestroyArray(prhs[2]);

43109
          mxDestroyArray(prhs[3]);

43110
        }

43111


43112
#else

43113


43114
        {

43115
          RateLimiter_sf(childS);

43116
          sfcnInitializeSizes(childS);

43117
        }

43118


43119
#endif

43120


43121
        sfcnInitializeSampleTimes(childS);

43122


43123
        /* adjust sample time */

43124
        ssSetSampleTime(childS, 0, 0.0);

43125
        ssSetOffsetTime(childS, 0, 0.0);

43126
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

43127


43128
        /* set compiled values of dynamic vector attributes */

43129
        ssSetNumNonsampledZCs(childS, 0);

43130


43131
        /* Update connectivity flags for each port */

43132
        _ssSetInputPortConnected(childS, 0, 1);

43133
        _ssSetInputPortConnected(childS, 1, 1);

43134
        _ssSetInputPortConnected(childS, 2, 1);

43135
        _ssSetInputPortConnected(childS, 3, 1);

43136
        _ssSetInputPortConnected(childS, 4, 1);

43137
        _ssSetOutputPortConnected(childS, 0, 1);

43138
        _ssSetOutputPortConnected(childS, 1, 1);

43139
        _ssSetOutputPortBeingMerged(childS, 0, 0);

43140
        _ssSetOutputPortBeingMerged(childS, 1, 0);

43141


43142
        /* Update the BufferDstPort flags for each input port */

43143
        _ssSetInputPortBufferDstPort(childS, 0, -1);

43144
        _ssSetInputPortBufferDstPort(childS, 1, -1);

43145
        _ssSetInputPortBufferDstPort(childS, 2, -1);

43146
        _ssSetInputPortBufferDstPort(childS, 3, -1);

43147
        _ssSetInputPortBufferDstPort(childS, 4, -1);

43148
      }

43149


43150
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S279>/Generated S-Function (Gain_sf) */

43151
      {

43152
        SimStruct *childS = ssGetSFunction(rts, 164);

43153


43154
        /* timing info */

43155
        time_T *sfcnPeriod;

43156
        time_T *sfcnOffset;

43157
        int_T *sfcnTsMap;

43158
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

43159
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

43160
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

43161
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

43162
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

43163
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

43164
        (void) memset((void*)sfcnPeriod, 0,

43165
                      sizeof(time_T)*1);

43166
        (void) memset((void*)sfcnOffset, 0,

43167
                      sizeof(time_T)*1);

43168
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

43169
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

43170
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

43171


43172
        /* Set up the mdlInfo pointer */

43173
# ifdef USE_RTMODEL

43174


43175
        {

43176
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

43177
              struct _ssBlkInfo2));

43178
          ss_VALIDATE_MEMORY(rts,blkInfo2);

43179
          ssSetBlkInfo2Ptr(childS, blkInfo2);

43180
        }

43181


43182
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

43183


43184
# else

43185


43186
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

43187


43188
# endif                                /* USE_RTMODEL */

43189


43190
        /* Allocate memory of model methods 2 */

43191
        {

43192
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

43193
            malloc(sizeof(struct _ssSFcnModelMethods2));

43194
          ss_VALIDATE_MEMORY(rts,methods2);

43195
          ssSetModelMethods2(childS, methods2);

43196
        }

43197


43198
        /* Allocate memory of model methods 3 */

43199
        {

43200
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

43201
            malloc(sizeof(struct _ssSFcnModelMethods3));

43202
          ss_VALIDATE_MEMORY(rts,methods3);

43203
          ssSetModelMethods3(childS, methods3);

43204
        }

43205


43206
        /* Allocate memory for states auxilliary information */

43207
        {

43208
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

43209
            (sizeof(struct _ssStatesInfo2));

43210
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

43211
            malloc(sizeof(ssPeriodicStatesInfo));

43212
          ss_VALIDATE_MEMORY(rts,statesInfo2);

43213
          ssSetStatesInfo2(childS, statesInfo2);

43214
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

43215
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

43216
        }

43217


43218
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

43219
          RegNumInputPorts);

43220
        ssSetRegNumInputPortsFcnArg(childS,childS);

43221


43222
        /* inputs */

43223
        {

43224
          struct _ssPortInputs *inputPortInfo =

43225
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

43226
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

43227
          _ssSetNumInputPorts(childS, 2);

43228
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

43229


43230
          /* port 0 */

43231
          {

43232
            real32_T const **sfcnUPtrs = (real32_T const **)

43233
              malloc(1 * sizeof(real32_T *));

43234
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43235
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

43236
              ssGetLocalBlockIO(rts))->Sum1_o;

43237
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

43238
            _ssSetInputPortNumDimensions(childS, 0, 1);

43239
            ssSetInputPortWidth(childS, 0, 1);

43240
          }

43241


43242
          /* port 1 */

43243
          {

43244
            real32_T const **sfcnUPtrs = (real32_T const **)

43245
              malloc(1 * sizeof(real32_T *));

43246
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43247
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

43248
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

43249
            _ssSetInputPortNumDimensions(childS, 1, 1);

43250
            ssSetInputPortWidth(childS, 1, 1);

43251
          }

43252
        }

43253


43254
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

43255
          RegNumOutputPorts);

43256
        ssSetRegNumOutputPortsFcnArg(childS,childS);

43257


43258
        /* outputs */

43259
        {

43260
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

43261
            calloc(1, sizeof(struct _ssPortOutputs));

43262
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

43263
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

43264
          _ssSetNumOutputPorts(childS, 1);

43265


43266
          /* port 0 */

43267
          {

43268
            _ssSetOutputPortNumDimensions(childS, 0, 1);

43269
            ssSetOutputPortWidth(childS, 0, 1);

43270
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

43271
              ssGetLocalBlockIO(rts))->GeneratedSFunction_gq4));

43272
          }

43273
        }

43274


43275
        /* path info */

43276
        _ssSetModelName(childS, "Gain_sf");

43277
        _ssSetPath(childS,

43278
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/GNCinit1/apinit/lon/gain/Generated S-Function");

43279
        if (ssGetRTModel(rts) == (NULL)) {

43280
          _ssSetParentSS(childS, rts);

43281
          _ssSetRootSS(childS, ssGetRootSS(rts));

43282
        } else {

43283
          ssSetRTModel(childS,ssGetRTModel(rts));

43284
          _ssSetParentSS(childS, (NULL));

43285
          _ssSetRootSS(childS, childS);

43286
        }

43287


43288
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

43289
        (childS)->regDataType.arg1 = ((void *)(childS));

43290
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

43291
          FcnSetErrorStatus);

43292
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

43293
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

43294
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

43295
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

43296


43297
        /* registration */

43298
#if defined(MATLAB_MEX_FILE)

43299


43300
        {

43301
          int_T i;

43302
          mxArray *plhs[1];

43303
          mxArray *prhs[4];

43304
          double *pr;

43305
          volatile int_T *intS = (int_T *)&childS;

43306
          int_T addrlen = sizeof(SimStruct *);

43307
          int_T m = addrlen/sizeof(int_T) + 1;

43308
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

43309
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

43310
          pr = mxGetPr(prhs[1]);

43311
          for (i = 0; i < m - 1; i++) {

43312
            pr[i] = (double)intS[i];

43313
          }

43314


43315
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

43316
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

43317
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

43318


43319
          /* Reset port dimensions info functions because the S-function

43320
           * and accelerator mex-files explicitly set their dimensions,

43321
           * i.e., they are not dynamically sized. For this case, the

43322
           * mex-file is responsible for the dimensions info memory

43323
           * and Simulink should not free it. This is achieved by

43324
           * setting the following two methods to NULL.

43325
           */

43326
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

43327
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

43328


43329
          /*

43330
           * Setup function pointers and call mdlInitializeSizes via

43331
           * simulink.c

43332
           */

43333
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

43334
          mxDestroyArray(plhs[0]);

43335
          mxDestroyArray(prhs[0]);

43336
          mxDestroyArray(prhs[1]);

43337
          mxDestroyArray(prhs[2]);

43338
          mxDestroyArray(prhs[3]);

43339
        }

43340


43341
#else

43342


43343
        {

43344
          Gain_sf(childS);

43345
          sfcnInitializeSizes(childS);

43346
        }

43347


43348
#endif

43349


43350
        sfcnInitializeSampleTimes(childS);

43351


43352
        /* adjust sample time */

43353
        ssSetSampleTime(childS, 0, 0.0);

43354
        ssSetOffsetTime(childS, 0, 0.0);

43355
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

43356


43357
        /* set compiled values of dynamic vector attributes */

43358
        ssSetNumNonsampledZCs(childS, 0);

43359


43360
        /* Update connectivity flags for each port */

43361
        _ssSetInputPortConnected(childS, 0, 1);

43362
        _ssSetInputPortConnected(childS, 1, 1);

43363
        _ssSetOutputPortConnected(childS, 0, 1);

43364
        _ssSetOutputPortBeingMerged(childS, 0, 0);

43365


43366
        /* Update the BufferDstPort flags for each input port */

43367
        _ssSetInputPortBufferDstPort(childS, 0, -1);

43368
        _ssSetInputPortBufferDstPort(childS, 1, -1);

43369
      }

43370


43371
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S280>/Generated S-Function (Gain_sf) */

43372
      {

43373
        SimStruct *childS = ssGetSFunction(rts, 165);

43374


43375
        /* timing info */

43376
        time_T *sfcnPeriod;

43377
        time_T *sfcnOffset;

43378
        int_T *sfcnTsMap;

43379
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

43380
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

43381
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

43382
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

43383
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

43384
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

43385
        (void) memset((void*)sfcnPeriod, 0,

43386
                      sizeof(time_T)*1);

43387
        (void) memset((void*)sfcnOffset, 0,

43388
                      sizeof(time_T)*1);

43389
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

43390
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

43391
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

43392


43393
        /* Set up the mdlInfo pointer */

43394
# ifdef USE_RTMODEL

43395


43396
        {

43397
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

43398
              struct _ssBlkInfo2));

43399
          ss_VALIDATE_MEMORY(rts,blkInfo2);

43400
          ssSetBlkInfo2Ptr(childS, blkInfo2);

43401
        }

43402


43403
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

43404


43405
# else

43406


43407
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

43408


43409
# endif                                /* USE_RTMODEL */

43410


43411
        /* Allocate memory of model methods 2 */

43412
        {

43413
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

43414
            malloc(sizeof(struct _ssSFcnModelMethods2));

43415
          ss_VALIDATE_MEMORY(rts,methods2);

43416
          ssSetModelMethods2(childS, methods2);

43417
        }

43418


43419
        /* Allocate memory of model methods 3 */

43420
        {

43421
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

43422
            malloc(sizeof(struct _ssSFcnModelMethods3));

43423
          ss_VALIDATE_MEMORY(rts,methods3);

43424
          ssSetModelMethods3(childS, methods3);

43425
        }

43426


43427
        /* Allocate memory for states auxilliary information */

43428
        {

43429
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

43430
            (sizeof(struct _ssStatesInfo2));

43431
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

43432
            malloc(sizeof(ssPeriodicStatesInfo));

43433
          ss_VALIDATE_MEMORY(rts,statesInfo2);

43434
          ssSetStatesInfo2(childS, statesInfo2);

43435
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

43436
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

43437
        }

43438


43439
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

43440
          RegNumInputPorts);

43441
        ssSetRegNumInputPortsFcnArg(childS,childS);

43442


43443
        /* inputs */

43444
        {

43445
          struct _ssPortInputs *inputPortInfo =

43446
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

43447
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

43448
          _ssSetNumInputPorts(childS, 2);

43449
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

43450


43451
          /* port 0 */

43452
          {

43453
            real32_T const **sfcnUPtrs = (real32_T const **)

43454
              malloc(1 * sizeof(real32_T *));

43455
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43456
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

43457
              ssGetLocalBlockIO(rts))->Saturation_bq;

43458
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

43459
            _ssSetInputPortNumDimensions(childS, 0, 1);

43460
            ssSetInputPortWidth(childS, 0, 1);

43461
          }

43462


43463
          /* port 1 */

43464
          {

43465
            real32_T const **sfcnUPtrs = (real32_T const **)

43466
              malloc(1 * sizeof(real32_T *));

43467
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43468
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;

43469
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

43470
            _ssSetInputPortNumDimensions(childS, 1, 1);

43471
            ssSetInputPortWidth(childS, 1, 1);

43472
          }

43473
        }

43474


43475
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

43476
          RegNumOutputPorts);

43477
        ssSetRegNumOutputPortsFcnArg(childS,childS);

43478


43479
        /* outputs */

43480
        {

43481
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

43482
            calloc(1, sizeof(struct _ssPortOutputs));

43483
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

43484
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

43485
          _ssSetNumOutputPorts(childS, 1);

43486


43487
          /* port 0 */

43488
          {

43489
            _ssSetOutputPortNumDimensions(childS, 0, 1);

43490
            ssSetOutputPortWidth(childS, 0, 1);

43491
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

43492
              ssGetLocalBlockIO(rts))->GeneratedSFunction_dw));

43493
          }

43494
        }

43495


43496
        /* path info */

43497
        _ssSetModelName(childS, "Gain_sf");

43498
        _ssSetPath(childS,

43499
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/GNCinit1/apinit/lon/gain1/Generated S-Function");

43500
        if (ssGetRTModel(rts) == (NULL)) {

43501
          _ssSetParentSS(childS, rts);

43502
          _ssSetRootSS(childS, ssGetRootSS(rts));

43503
        } else {

43504
          ssSetRTModel(childS,ssGetRTModel(rts));

43505
          _ssSetParentSS(childS, (NULL));

43506
          _ssSetRootSS(childS, childS);

43507
        }

43508


43509
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

43510
        (childS)->regDataType.arg1 = ((void *)(childS));

43511
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

43512
          FcnSetErrorStatus);

43513
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

43514
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

43515
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

43516
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

43517


43518
        /* registration */

43519
#if defined(MATLAB_MEX_FILE)

43520


43521
        {

43522
          int_T i;

43523
          mxArray *plhs[1];

43524
          mxArray *prhs[4];

43525
          double *pr;

43526
          volatile int_T *intS = (int_T *)&childS;

43527
          int_T addrlen = sizeof(SimStruct *);

43528
          int_T m = addrlen/sizeof(int_T) + 1;

43529
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

43530
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

43531
          pr = mxGetPr(prhs[1]);

43532
          for (i = 0; i < m - 1; i++) {

43533
            pr[i] = (double)intS[i];

43534
          }

43535


43536
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

43537
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

43538
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

43539


43540
          /* Reset port dimensions info functions because the S-function

43541
           * and accelerator mex-files explicitly set their dimensions,

43542
           * i.e., they are not dynamically sized. For this case, the

43543
           * mex-file is responsible for the dimensions info memory

43544
           * and Simulink should not free it. This is achieved by

43545
           * setting the following two methods to NULL.

43546
           */

43547
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

43548
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

43549


43550
          /*

43551
           * Setup function pointers and call mdlInitializeSizes via

43552
           * simulink.c

43553
           */

43554
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

43555
          mxDestroyArray(plhs[0]);

43556
          mxDestroyArray(prhs[0]);

43557
          mxDestroyArray(prhs[1]);

43558
          mxDestroyArray(prhs[2]);

43559
          mxDestroyArray(prhs[3]);

43560
        }

43561


43562
#else

43563


43564
        {

43565
          Gain_sf(childS);

43566
          sfcnInitializeSizes(childS);

43567
        }

43568


43569
#endif

43570


43571
        sfcnInitializeSampleTimes(childS);

43572


43573
        /* adjust sample time */

43574
        ssSetSampleTime(childS, 0, 0.0);

43575
        ssSetOffsetTime(childS, 0, 0.0);

43576
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

43577


43578
        /* set compiled values of dynamic vector attributes */

43579
        ssSetNumNonsampledZCs(childS, 0);

43580


43581
        /* Update connectivity flags for each port */

43582
        _ssSetInputPortConnected(childS, 0, 1);

43583
        _ssSetInputPortConnected(childS, 1, 1);

43584
        _ssSetOutputPortConnected(childS, 0, 1);

43585
        _ssSetOutputPortBeingMerged(childS, 0, 0);

43586


43587
        /* Update the BufferDstPort flags for each input port */

43588
        _ssSetInputPortBufferDstPort(childS, 0, -1);

43589
        _ssSetInputPortBufferDstPort(childS, 1, -1);

43590
      }

43591


43592
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S281>/Generated S-Function (Gain_sf) */

43593
      {

43594
        SimStruct *childS = ssGetSFunction(rts, 166);

43595


43596
        /* timing info */

43597
        time_T *sfcnPeriod;

43598
        time_T *sfcnOffset;

43599
        int_T *sfcnTsMap;

43600
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

43601
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

43602
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

43603
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

43604
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

43605
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

43606
        (void) memset((void*)sfcnPeriod, 0,

43607
                      sizeof(time_T)*1);

43608
        (void) memset((void*)sfcnOffset, 0,

43609
                      sizeof(time_T)*1);

43610
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

43611
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

43612
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

43613


43614
        /* Set up the mdlInfo pointer */

43615
# ifdef USE_RTMODEL

43616


43617
        {

43618
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

43619
              struct _ssBlkInfo2));

43620
          ss_VALIDATE_MEMORY(rts,blkInfo2);

43621
          ssSetBlkInfo2Ptr(childS, blkInfo2);

43622
        }

43623


43624
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

43625


43626
# else

43627


43628
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

43629


43630
# endif                                /* USE_RTMODEL */

43631


43632
        /* Allocate memory of model methods 2 */

43633
        {

43634
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

43635
            malloc(sizeof(struct _ssSFcnModelMethods2));

43636
          ss_VALIDATE_MEMORY(rts,methods2);

43637
          ssSetModelMethods2(childS, methods2);

43638
        }

43639


43640
        /* Allocate memory of model methods 3 */

43641
        {

43642
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

43643
            malloc(sizeof(struct _ssSFcnModelMethods3));

43644
          ss_VALIDATE_MEMORY(rts,methods3);

43645
          ssSetModelMethods3(childS, methods3);

43646
        }

43647


43648
        /* Allocate memory for states auxilliary information */

43649
        {

43650
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

43651
            (sizeof(struct _ssStatesInfo2));

43652
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

43653
            malloc(sizeof(ssPeriodicStatesInfo));

43654
          ss_VALIDATE_MEMORY(rts,statesInfo2);

43655
          ssSetStatesInfo2(childS, statesInfo2);

43656
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

43657
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

43658
        }

43659


43660
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

43661
          RegNumInputPorts);

43662
        ssSetRegNumInputPortsFcnArg(childS,childS);

43663


43664
        /* inputs */

43665
        {

43666
          struct _ssPortInputs *inputPortInfo =

43667
            (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));

43668
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

43669
          _ssSetNumInputPorts(childS, 2);

43670
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

43671


43672
          /* port 0 */

43673
          {

43674
            real32_T const **sfcnUPtrs = (real32_T const **)

43675
              malloc(1 * sizeof(real32_T *));

43676
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43677
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

43678
              ssGetLocalBlockIO(rts))->Saturation_bq;

43679
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

43680
            _ssSetInputPortNumDimensions(childS, 0, 1);

43681
            ssSetInputPortWidth(childS, 0, 1);

43682
          }

43683


43684
          /* port 1 */

43685
          {

43686
            real32_T const **sfcnUPtrs = (real32_T const **)

43687
              malloc(1 * sizeof(real32_T *));

43688
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43689
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;

43690
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

43691
            _ssSetInputPortNumDimensions(childS, 1, 1);

43692
            ssSetInputPortWidth(childS, 1, 1);

43693
          }

43694
        }

43695


43696
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

43697
          RegNumOutputPorts);

43698
        ssSetRegNumOutputPortsFcnArg(childS,childS);

43699


43700
        /* outputs */

43701
        {

43702
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

43703
            calloc(1, sizeof(struct _ssPortOutputs));

43704
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

43705
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

43706
          _ssSetNumOutputPorts(childS, 1);

43707


43708
          /* port 0 */

43709
          {

43710
            _ssSetOutputPortNumDimensions(childS, 0, 1);

43711
            ssSetOutputPortWidth(childS, 0, 1);

43712
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

43713
              ssGetLocalBlockIO(rts))->GeneratedSFunction_d4));

43714
          }

43715
        }

43716


43717
        /* path info */

43718
        _ssSetModelName(childS, "Gain_sf");

43719
        _ssSetPath(childS,

43720
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/GNCinit1/apinit/lon/gain2/Generated S-Function");

43721
        if (ssGetRTModel(rts) == (NULL)) {

43722
          _ssSetParentSS(childS, rts);

43723
          _ssSetRootSS(childS, ssGetRootSS(rts));

43724
        } else {

43725
          ssSetRTModel(childS,ssGetRTModel(rts));

43726
          _ssSetParentSS(childS, (NULL));

43727
          _ssSetRootSS(childS, childS);

43728
        }

43729


43730
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

43731
        (childS)->regDataType.arg1 = ((void *)(childS));

43732
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

43733
          FcnSetErrorStatus);

43734
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

43735
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

43736
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

43737
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

43738


43739
        /* registration */

43740
#if defined(MATLAB_MEX_FILE)

43741


43742
        {

43743
          int_T i;

43744
          mxArray *plhs[1];

43745
          mxArray *prhs[4];

43746
          double *pr;

43747
          volatile int_T *intS = (int_T *)&childS;

43748
          int_T addrlen = sizeof(SimStruct *);

43749
          int_T m = addrlen/sizeof(int_T) + 1;

43750
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

43751
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

43752
          pr = mxGetPr(prhs[1]);

43753
          for (i = 0; i < m - 1; i++) {

43754
            pr[i] = (double)intS[i];

43755
          }

43756


43757
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

43758
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

43759
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

43760


43761
          /* Reset port dimensions info functions because the S-function

43762
           * and accelerator mex-files explicitly set their dimensions,

43763
           * i.e., they are not dynamically sized. For this case, the

43764
           * mex-file is responsible for the dimensions info memory

43765
           * and Simulink should not free it. This is achieved by

43766
           * setting the following two methods to NULL.

43767
           */

43768
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

43769
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

43770


43771
          /*

43772
           * Setup function pointers and call mdlInitializeSizes via

43773
           * simulink.c

43774
           */

43775
          mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");

43776
          mxDestroyArray(plhs[0]);

43777
          mxDestroyArray(prhs[0]);

43778
          mxDestroyArray(prhs[1]);

43779
          mxDestroyArray(prhs[2]);

43780
          mxDestroyArray(prhs[3]);

43781
        }

43782


43783
#else

43784


43785
        {

43786
          Gain_sf(childS);

43787
          sfcnInitializeSizes(childS);

43788
        }

43789


43790
#endif

43791


43792
        sfcnInitializeSampleTimes(childS);

43793


43794
        /* adjust sample time */

43795
        ssSetSampleTime(childS, 0, 0.0);

43796
        ssSetOffsetTime(childS, 0, 0.0);

43797
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

43798


43799
        /* set compiled values of dynamic vector attributes */

43800
        ssSetNumNonsampledZCs(childS, 0);

43801


43802
        /* Update connectivity flags for each port */

43803
        _ssSetInputPortConnected(childS, 0, 1);

43804
        _ssSetInputPortConnected(childS, 1, 1);

43805
        _ssSetOutputPortConnected(childS, 0, 1);

43806
        _ssSetOutputPortBeingMerged(childS, 0, 0);

43807


43808
        /* Update the BufferDstPort flags for each input port */

43809
        _ssSetInputPortBufferDstPort(childS, 0, -1);

43810
        _ssSetInputPortBufferDstPort(childS, 1, -1);

43811
      }

43812


43813
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S306>/Generated S-Function15 (StickGradientDeadZone_sf) */

43814
      {

43815
        SimStruct *childS = ssGetSFunction(rts, 167);

43816


43817
        /* timing info */

43818
        time_T *sfcnPeriod;

43819
        time_T *sfcnOffset;

43820
        int_T *sfcnTsMap;

43821
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

43822
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

43823
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

43824
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

43825
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

43826
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

43827
        (void) memset((void*)sfcnPeriod, 0,

43828
                      sizeof(time_T)*1);

43829
        (void) memset((void*)sfcnOffset, 0,

43830
                      sizeof(time_T)*1);

43831
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

43832
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

43833
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

43834


43835
        /* Set up the mdlInfo pointer */

43836
# ifdef USE_RTMODEL

43837


43838
        {

43839
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

43840
              struct _ssBlkInfo2));

43841
          ss_VALIDATE_MEMORY(rts,blkInfo2);

43842
          ssSetBlkInfo2Ptr(childS, blkInfo2);

43843
        }

43844


43845
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

43846


43847
# else

43848


43849
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

43850


43851
# endif                                /* USE_RTMODEL */

43852


43853
        /* Allocate memory of model methods 2 */

43854
        {

43855
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

43856
            malloc(sizeof(struct _ssSFcnModelMethods2));

43857
          ss_VALIDATE_MEMORY(rts,methods2);

43858
          ssSetModelMethods2(childS, methods2);

43859
        }

43860


43861
        /* Allocate memory of model methods 3 */

43862
        {

43863
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

43864
            malloc(sizeof(struct _ssSFcnModelMethods3));

43865
          ss_VALIDATE_MEMORY(rts,methods3);

43866
          ssSetModelMethods3(childS, methods3);

43867
        }

43868


43869
        /* Allocate memory for states auxilliary information */

43870
        {

43871
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

43872
            (sizeof(struct _ssStatesInfo2));

43873
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

43874
            malloc(sizeof(ssPeriodicStatesInfo));

43875
          ss_VALIDATE_MEMORY(rts,statesInfo2);

43876
          ssSetStatesInfo2(childS, statesInfo2);

43877
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

43878
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

43879
        }

43880


43881
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

43882
          RegNumInputPorts);

43883
        ssSetRegNumInputPortsFcnArg(childS,childS);

43884


43885
        /* inputs */

43886
        {

43887
          struct _ssPortInputs *inputPortInfo =

43888
            (struct _ssPortInputs *) calloc(4, sizeof(struct _ssPortInputs));

43889
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

43890
          _ssSetNumInputPorts(childS, 4);

43891
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

43892


43893
          /* port 0 */

43894
          {

43895
            real32_T const **sfcnUPtrs = (real32_T const **)

43896
              malloc(1 * sizeof(real32_T *));

43897
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43898
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

43899
              ssGetLocalBlockIO(rts))->Switch_lo[1];

43900
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

43901
            _ssSetInputPortNumDimensions(childS, 0, 1);

43902
            ssSetInputPortWidth(childS, 0, 1);

43903
          }

43904


43905
          /* port 1 */

43906
          {

43907
            real32_T const **sfcnUPtrs = (real32_T const **)

43908
              malloc(1 * sizeof(real32_T *));

43909
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43910
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

43911
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

43912
            _ssSetInputPortNumDimensions(childS, 1, 1);

43913
            ssSetInputPortWidth(childS, 1, 1);

43914
          }

43915


43916
          /* port 2 */

43917
          {

43918
            real32_T const **sfcnUPtrs = (real32_T const **)

43919
              malloc(1 * sizeof(real32_T *));

43920
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43921
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

43922
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

43923
            _ssSetInputPortNumDimensions(childS, 2, 1);

43924
            ssSetInputPortWidth(childS, 2, 1);

43925
          }

43926


43927
          /* port 3 */

43928
          {

43929
            real32_T const **sfcnUPtrs = (real32_T const **)

43930
              malloc(1 * sizeof(real32_T *));

43931
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

43932
            sfcnUPtrs[0] = (real32_T const *)

43933
              &AFCS_MODEL1_ConstP.Constant2_Value_o;

43934
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

43935
            _ssSetInputPortNumDimensions(childS, 3, 1);

43936
            ssSetInputPortWidth(childS, 3, 1);

43937
          }

43938
        }

43939


43940
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

43941
          RegNumOutputPorts);

43942
        ssSetRegNumOutputPortsFcnArg(childS,childS);

43943


43944
        /* outputs */

43945
        {

43946
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

43947
            calloc(1, sizeof(struct _ssPortOutputs));

43948
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

43949
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

43950
          _ssSetNumOutputPorts(childS, 1);

43951


43952
          /* port 0 */

43953
          {

43954
            _ssSetOutputPortNumDimensions(childS, 0, 1);

43955
            ssSetOutputPortWidth(childS, 0, 1);

43956
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

43957
              ssGetLocalBlockIO(rts))->GeneratedSFunction15));

43958
          }

43959
        }

43960


43961
        /* path info */

43962
        _ssSetModelName(childS, "StickGradientDeadZone_sf");

43963
        _ssSetPath(childS,

43964
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Pilot/Stick Gradient DeadZone2/Generated S-Function15");

43965
        if (ssGetRTModel(rts) == (NULL)) {

43966
          _ssSetParentSS(childS, rts);

43967
          _ssSetRootSS(childS, ssGetRootSS(rts));

43968
        } else {

43969
          ssSetRTModel(childS,ssGetRTModel(rts));

43970
          _ssSetParentSS(childS, (NULL));

43971
          _ssSetRootSS(childS, childS);

43972
        }

43973


43974
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

43975
        (childS)->regDataType.arg1 = ((void *)(childS));

43976
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

43977
          FcnSetErrorStatus);

43978
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

43979
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

43980
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

43981
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

43982


43983
        /* registration */

43984
#if defined(MATLAB_MEX_FILE)

43985


43986
        {

43987
          int_T i;

43988
          mxArray *plhs[1];

43989
          mxArray *prhs[4];

43990
          double *pr;

43991
          volatile int_T *intS = (int_T *)&childS;

43992
          int_T addrlen = sizeof(SimStruct *);

43993
          int_T m = addrlen/sizeof(int_T) + 1;

43994
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

43995
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

43996
          pr = mxGetPr(prhs[1]);

43997
          for (i = 0; i < m - 1; i++) {

43998
            pr[i] = (double)intS[i];

43999
          }

44000


44001
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

44002
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

44003
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

44004


44005
          /* Reset port dimensions info functions because the S-function

44006
           * and accelerator mex-files explicitly set their dimensions,

44007
           * i.e., they are not dynamically sized. For this case, the

44008
           * mex-file is responsible for the dimensions info memory

44009
           * and Simulink should not free it. This is achieved by

44010
           * setting the following two methods to NULL.

44011
           */

44012
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

44013
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

44014


44015
          /*

44016
           * Setup function pointers and call mdlInitializeSizes via

44017
           * simulink.c

44018
           */

44019
          mexCallMATLAB(1, plhs, 4, prhs, "StickGradientDeadZone_sf");

44020
          mxDestroyArray(plhs[0]);

44021
          mxDestroyArray(prhs[0]);

44022
          mxDestroyArray(prhs[1]);

44023
          mxDestroyArray(prhs[2]);

44024
          mxDestroyArray(prhs[3]);

44025
        }

44026


44027
#else

44028


44029
        {

44030
          StickGradientDeadZone_sf(childS);

44031
          sfcnInitializeSizes(childS);

44032
        }

44033


44034
#endif

44035


44036
        sfcnInitializeSampleTimes(childS);

44037


44038
        /* adjust sample time */

44039
        ssSetSampleTime(childS, 0, 0.0);

44040
        ssSetOffsetTime(childS, 0, 0.0);

44041
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

44042


44043
        /* set compiled values of dynamic vector attributes */

44044
        ssSetNumNonsampledZCs(childS, 0);

44045


44046
        /* Update connectivity flags for each port */

44047
        _ssSetInputPortConnected(childS, 0, 1);

44048
        _ssSetInputPortConnected(childS, 1, 1);

44049
        _ssSetInputPortConnected(childS, 2, 1);

44050
        _ssSetInputPortConnected(childS, 3, 1);

44051
        _ssSetOutputPortConnected(childS, 0, 1);

44052
        _ssSetOutputPortBeingMerged(childS, 0, 0);

44053


44054
        /* Update the BufferDstPort flags for each input port */

44055
        _ssSetInputPortBufferDstPort(childS, 0, -1);

44056
        _ssSetInputPortBufferDstPort(childS, 1, -1);

44057
        _ssSetInputPortBufferDstPort(childS, 2, -1);

44058
        _ssSetInputPortBufferDstPort(childS, 3, -1);

44059
      }

44060


44061
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S305>/Generated S-Function15 (StickGradientDeadZone_sf) */

44062
      {

44063
        SimStruct *childS = ssGetSFunction(rts, 168);

44064


44065
        /* timing info */

44066
        time_T *sfcnPeriod;

44067
        time_T *sfcnOffset;

44068
        int_T *sfcnTsMap;

44069
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

44070
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

44071
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

44072
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

44073
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

44074
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

44075
        (void) memset((void*)sfcnPeriod, 0,

44076
                      sizeof(time_T)*1);

44077
        (void) memset((void*)sfcnOffset, 0,

44078
                      sizeof(time_T)*1);

44079
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

44080
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

44081
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

44082


44083
        /* Set up the mdlInfo pointer */

44084
# ifdef USE_RTMODEL

44085


44086
        {

44087
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

44088
              struct _ssBlkInfo2));

44089
          ss_VALIDATE_MEMORY(rts,blkInfo2);

44090
          ssSetBlkInfo2Ptr(childS, blkInfo2);

44091
        }

44092


44093
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

44094


44095
# else

44096


44097
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

44098


44099
# endif                                /* USE_RTMODEL */

44100


44101
        /* Allocate memory of model methods 2 */

44102
        {

44103
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

44104
            malloc(sizeof(struct _ssSFcnModelMethods2));

44105
          ss_VALIDATE_MEMORY(rts,methods2);

44106
          ssSetModelMethods2(childS, methods2);

44107
        }

44108


44109
        /* Allocate memory of model methods 3 */

44110
        {

44111
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

44112
            malloc(sizeof(struct _ssSFcnModelMethods3));

44113
          ss_VALIDATE_MEMORY(rts,methods3);

44114
          ssSetModelMethods3(childS, methods3);

44115
        }

44116


44117
        /* Allocate memory for states auxilliary information */

44118
        {

44119
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

44120
            (sizeof(struct _ssStatesInfo2));

44121
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

44122
            malloc(sizeof(ssPeriodicStatesInfo));

44123
          ss_VALIDATE_MEMORY(rts,statesInfo2);

44124
          ssSetStatesInfo2(childS, statesInfo2);

44125
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

44126
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

44127
        }

44128


44129
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

44130
          RegNumInputPorts);

44131
        ssSetRegNumInputPortsFcnArg(childS,childS);

44132


44133
        /* inputs */

44134
        {

44135
          struct _ssPortInputs *inputPortInfo =

44136
            (struct _ssPortInputs *) calloc(4, sizeof(struct _ssPortInputs));

44137
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

44138
          _ssSetNumInputPorts(childS, 4);

44139
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

44140


44141
          /* port 0 */

44142
          {

44143
            real32_T const **sfcnUPtrs = (real32_T const **)

44144
              malloc(1 * sizeof(real32_T *));

44145
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44146
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

44147
              ssGetLocalBlockIO(rts))->Switch_lo[0];

44148
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

44149
            _ssSetInputPortNumDimensions(childS, 0, 1);

44150
            ssSetInputPortWidth(childS, 0, 1);

44151
          }

44152


44153
          /* port 1 */

44154
          {

44155
            real32_T const **sfcnUPtrs = (real32_T const **)

44156
              malloc(1 * sizeof(real32_T *));

44157
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44158
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

44159
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

44160
            _ssSetInputPortNumDimensions(childS, 1, 1);

44161
            ssSetInputPortWidth(childS, 1, 1);

44162
          }

44163


44164
          /* port 2 */

44165
          {

44166
            real32_T const **sfcnUPtrs = (real32_T const **)

44167
              malloc(1 * sizeof(real32_T *));

44168
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44169
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;

44170
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

44171
            _ssSetInputPortNumDimensions(childS, 2, 1);

44172
            ssSetInputPortWidth(childS, 2, 1);

44173
          }

44174


44175
          /* port 3 */

44176
          {

44177
            real32_T const **sfcnUPtrs = (real32_T const **)

44178
              malloc(1 * sizeof(real32_T *));

44179
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44180
            sfcnUPtrs[0] = (real32_T const *)

44181
              &AFCS_MODEL1_ConstP.Constant2_Value_o;

44182
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

44183
            _ssSetInputPortNumDimensions(childS, 3, 1);

44184
            ssSetInputPortWidth(childS, 3, 1);

44185
          }

44186
        }

44187


44188
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

44189
          RegNumOutputPorts);

44190
        ssSetRegNumOutputPortsFcnArg(childS,childS);

44191


44192
        /* outputs */

44193
        {

44194
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

44195
            calloc(1, sizeof(struct _ssPortOutputs));

44196
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

44197
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

44198
          _ssSetNumOutputPorts(childS, 1);

44199


44200
          /* port 0 */

44201
          {

44202
            _ssSetOutputPortNumDimensions(childS, 0, 1);

44203
            ssSetOutputPortWidth(childS, 0, 1);

44204
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

44205
              ssGetLocalBlockIO(rts))->GeneratedSFunction15_i));

44206
          }

44207
        }

44208


44209
        /* path info */

44210
        _ssSetModelName(childS, "StickGradientDeadZone_sf");

44211
        _ssSetPath(childS,

44212
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Pilot/Stick Gradient DeadZone1/Generated S-Function15");

44213
        if (ssGetRTModel(rts) == (NULL)) {

44214
          _ssSetParentSS(childS, rts);

44215
          _ssSetRootSS(childS, ssGetRootSS(rts));

44216
        } else {

44217
          ssSetRTModel(childS,ssGetRTModel(rts));

44218
          _ssSetParentSS(childS, (NULL));

44219
          _ssSetRootSS(childS, childS);

44220
        }

44221


44222
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

44223
        (childS)->regDataType.arg1 = ((void *)(childS));

44224
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

44225
          FcnSetErrorStatus);

44226
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

44227
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

44228
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

44229
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

44230


44231
        /* registration */

44232
#if defined(MATLAB_MEX_FILE)

44233


44234
        {

44235
          int_T i;

44236
          mxArray *plhs[1];

44237
          mxArray *prhs[4];

44238
          double *pr;

44239
          volatile int_T *intS = (int_T *)&childS;

44240
          int_T addrlen = sizeof(SimStruct *);

44241
          int_T m = addrlen/sizeof(int_T) + 1;

44242
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

44243
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

44244
          pr = mxGetPr(prhs[1]);

44245
          for (i = 0; i < m - 1; i++) {

44246
            pr[i] = (double)intS[i];

44247
          }

44248


44249
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

44250
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

44251
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

44252


44253
          /* Reset port dimensions info functions because the S-function

44254
           * and accelerator mex-files explicitly set their dimensions,

44255
           * i.e., they are not dynamically sized. For this case, the

44256
           * mex-file is responsible for the dimensions info memory

44257
           * and Simulink should not free it. This is achieved by

44258
           * setting the following two methods to NULL.

44259
           */

44260
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

44261
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

44262


44263
          /*

44264
           * Setup function pointers and call mdlInitializeSizes via

44265
           * simulink.c

44266
           */

44267
          mexCallMATLAB(1, plhs, 4, prhs, "StickGradientDeadZone_sf");

44268
          mxDestroyArray(plhs[0]);

44269
          mxDestroyArray(prhs[0]);

44270
          mxDestroyArray(prhs[1]);

44271
          mxDestroyArray(prhs[2]);

44272
          mxDestroyArray(prhs[3]);

44273
        }

44274


44275
#else

44276


44277
        {

44278
          StickGradientDeadZone_sf(childS);

44279
          sfcnInitializeSizes(childS);

44280
        }

44281


44282
#endif

44283


44284
        sfcnInitializeSampleTimes(childS);

44285


44286
        /* adjust sample time */

44287
        ssSetSampleTime(childS, 0, 0.0);

44288
        ssSetOffsetTime(childS, 0, 0.0);

44289
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

44290


44291
        /* set compiled values of dynamic vector attributes */

44292
        ssSetNumNonsampledZCs(childS, 0);

44293


44294
        /* Update connectivity flags for each port */

44295
        _ssSetInputPortConnected(childS, 0, 1);

44296
        _ssSetInputPortConnected(childS, 1, 1);

44297
        _ssSetInputPortConnected(childS, 2, 1);

44298
        _ssSetInputPortConnected(childS, 3, 1);

44299
        _ssSetOutputPortConnected(childS, 0, 1);

44300
        _ssSetOutputPortBeingMerged(childS, 0, 0);

44301


44302
        /* Update the BufferDstPort flags for each input port */

44303
        _ssSetInputPortBufferDstPort(childS, 0, -1);

44304
        _ssSetInputPortBufferDstPort(childS, 1, -1);

44305
        _ssSetInputPortBufferDstPort(childS, 2, -1);

44306
        _ssSetInputPortBufferDstPort(childS, 3, -1);

44307
      }

44308


44309
      /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S304>/Generated S-Function15 (StickGradientDeadZone_sf) */

44310
      {

44311
        SimStruct *childS = ssGetSFunction(rts, 169);

44312


44313
        /* timing info */

44314
        time_T *sfcnPeriod;

44315
        time_T *sfcnOffset;

44316
        int_T *sfcnTsMap;

44317
        sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));

44318
        ss_VALIDATE_MEMORY(rts,sfcnPeriod);

44319
        sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));

44320
        ss_VALIDATE_MEMORY(rts,sfcnOffset);

44321
        sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));

44322
        ss_VALIDATE_MEMORY(rts,sfcnTsMap);

44323
        (void) memset((void*)sfcnPeriod, 0,

44324
                      sizeof(time_T)*1);

44325
        (void) memset((void*)sfcnOffset, 0,

44326
                      sizeof(time_T)*1);

44327
        ssSetSampleTimePtr(childS, &sfcnPeriod[0]);

44328
        ssSetOffsetTimePtr(childS, &sfcnOffset[0]);

44329
        _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);

44330


44331
        /* Set up the mdlInfo pointer */

44332
# ifdef USE_RTMODEL

44333


44334
        {

44335
          struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(

44336
              struct _ssBlkInfo2));

44337
          ss_VALIDATE_MEMORY(rts,blkInfo2);

44338
          ssSetBlkInfo2Ptr(childS, blkInfo2);

44339
        }

44340


44341
        ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));

44342


44343
# else

44344


44345
        _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));

44346


44347
# endif                                /* USE_RTMODEL */

44348


44349
        /* Allocate memory of model methods 2 */

44350
        {

44351
          struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)

44352
            malloc(sizeof(struct _ssSFcnModelMethods2));

44353
          ss_VALIDATE_MEMORY(rts,methods2);

44354
          ssSetModelMethods2(childS, methods2);

44355
        }

44356


44357
        /* Allocate memory of model methods 3 */

44358
        {

44359
          struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)

44360
            malloc(sizeof(struct _ssSFcnModelMethods3));

44361
          ss_VALIDATE_MEMORY(rts,methods3);

44362
          ssSetModelMethods3(childS, methods3);

44363
        }

44364


44365
        /* Allocate memory for states auxilliary information */

44366
        {

44367
          struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc

44368
            (sizeof(struct _ssStatesInfo2));

44369
          ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)

44370
            malloc(sizeof(ssPeriodicStatesInfo));

44371
          ss_VALIDATE_MEMORY(rts,statesInfo2);

44372
          ssSetStatesInfo2(childS, statesInfo2);

44373
          ss_VALIDATE_MEMORY(rts,periodicStatesInfo);

44374
          ssSetPeriodicStatesInfo(childS, periodicStatesInfo);

44375
        }

44376


44377
        ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)

44378
          RegNumInputPorts);

44379
        ssSetRegNumInputPortsFcnArg(childS,childS);

44380


44381
        /* inputs */

44382
        {

44383
          struct _ssPortInputs *inputPortInfo =

44384
            (struct _ssPortInputs *) calloc(4, sizeof(struct _ssPortInputs));

44385
          ss_VALIDATE_MEMORY(rts,inputPortInfo);

44386
          _ssSetNumInputPorts(childS, 4);

44387
          ssSetPortInfoForInputs(childS, &inputPortInfo[0]);

44388


44389
          /* port 0 */

44390
          {

44391
            real32_T const **sfcnUPtrs = (real32_T const **)

44392
              malloc(1 * sizeof(real32_T *));

44393
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44394
            sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)

44395
              ssGetLocalBlockIO(rts))->Switch_lo[2];

44396
            _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);

44397
            _ssSetInputPortNumDimensions(childS, 0, 1);

44398
            ssSetInputPortWidth(childS, 0, 1);

44399
          }

44400


44401
          /* port 1 */

44402
          {

44403
            real32_T const **sfcnUPtrs = (real32_T const **)

44404
              malloc(1 * sizeof(real32_T *));

44405
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44406
            sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;

44407
            _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);

44408
            _ssSetInputPortNumDimensions(childS, 1, 1);

44409
            ssSetInputPortWidth(childS, 1, 1);

44410
          }

44411


44412
          /* port 2 */

44413
          {

44414
            real32_T const **sfcnUPtrs = (real32_T const **)

44415
              malloc(1 * sizeof(real32_T *));

44416
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44417
            sfcnUPtrs[0] = (real32_T const *)

44418
              &AFCS_MODEL1_ConstP.Constant4_Value_m;

44419
            _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);

44420
            _ssSetInputPortNumDimensions(childS, 2, 1);

44421
            ssSetInputPortWidth(childS, 2, 1);

44422
          }

44423


44424
          /* port 3 */

44425
          {

44426
            real32_T const **sfcnUPtrs = (real32_T const **)

44427
              malloc(1 * sizeof(real32_T *));

44428
            ss_VALIDATE_MEMORY(rts,sfcnUPtrs);

44429
            sfcnUPtrs[0] = (real32_T const *)

44430
              &AFCS_MODEL1_ConstP.Constant2_Value_o;

44431
            _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);

44432
            _ssSetInputPortNumDimensions(childS, 3, 1);

44433
            ssSetInputPortWidth(childS, 3, 1);

44434
          }

44435
        }

44436


44437
        ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)

44438
          RegNumOutputPorts);

44439
        ssSetRegNumOutputPortsFcnArg(childS,childS);

44440


44441
        /* outputs */

44442
        {

44443
          struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)

44444
            calloc(1, sizeof(struct _ssPortOutputs));

44445
          ss_VALIDATE_MEMORY(rts,outputPortInfo);

44446
          ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);

44447
          _ssSetNumOutputPorts(childS, 1);

44448


44449
          /* port 0 */

44450
          {

44451
            _ssSetOutputPortNumDimensions(childS, 0, 1);

44452
            ssSetOutputPortWidth(childS, 0, 1);

44453
            _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)

44454
              ssGetLocalBlockIO(rts))->GeneratedSFunction15_e));

44455
          }

44456
        }

44457


44458
        /* path info */

44459
        _ssSetModelName(childS, "StickGradientDeadZone_sf");

44460
        _ssSetPath(childS,

44461
                   "AFCS_MODEL1/AFCS_MODEL1/GNC/Pilot/Stick Gradient DeadZone/Generated S-Function15");

44462
        if (ssGetRTModel(rts) == (NULL)) {

44463
          _ssSetParentSS(childS, rts);

44464
          _ssSetRootSS(childS, ssGetRootSS(rts));

44465
        } else {

44466
          ssSetRTModel(childS,ssGetRTModel(rts));

44467
          _ssSetParentSS(childS, (NULL));

44468
          _ssSetRootSS(childS, childS);

44469
        }

44470


44471
        ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);

44472
        (childS)->regDataType.arg1 = ((void *)(childS));

44473
        (childS)->regDataType.registerFcn = ((OldRegisterDataType)

44474
          FcnSetErrorStatus);

44475
        (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);

44476
        (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);

44477
        (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);

44478
        (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);

44479


44480
        /* registration */

44481
#if defined(MATLAB_MEX_FILE)

44482


44483
        {

44484
          int_T i;

44485
          mxArray *plhs[1];

44486
          mxArray *prhs[4];

44487
          double *pr;

44488
          volatile int_T *intS = (int_T *)&childS;

44489
          int_T addrlen = sizeof(SimStruct *);

44490
          int_T m = addrlen/sizeof(int_T) + 1;

44491
          prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);

44492
          prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);

44493
          pr = mxGetPr(prhs[1]);

44494
          for (i = 0; i < m - 1; i++) {

44495
            pr[i] = (double)intS[i];

44496
          }

44497


44498
          pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;

44499
          prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);

44500
          prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);

44501


44502
          /* Reset port dimensions info functions because the S-function

44503
           * and accelerator mex-files explicitly set their dimensions,

44504
           * i.e., they are not dynamically sized. For this case, the

44505
           * mex-file is responsible for the dimensions info memory

44506
           * and Simulink should not free it. This is achieved by

44507
           * setting the following two methods to NULL.

44508
           */

44509
          ssSetRegInputPortDimensionInfoFcn(childS, (NULL));

44510
          ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));

44511


44512
          /*

44513
           * Setup function pointers and call mdlInitializeSizes via

44514
           * simulink.c

44515
           */

44516
          mexCallMATLAB(1, plhs, 4, prhs, "StickGradientDeadZone_sf");

44517
          mxDestroyArray(plhs[0]);

44518
          mxDestroyArray(prhs[0]);

44519
          mxDestroyArray(prhs[1]);

44520
          mxDestroyArray(prhs[2]);

44521
          mxDestroyArray(prhs[3]);

44522
        }

44523


44524
#else

44525


44526
        {

44527
          StickGradientDeadZone_sf(childS);

44528
          sfcnInitializeSizes(childS);

44529
        }

44530


44531
#endif

44532


44533
        sfcnInitializeSampleTimes(childS);

44534


44535
        /* adjust sample time */

44536
        ssSetSampleTime(childS, 0, 0.0);

44537
        ssSetOffsetTime(childS, 0, 0.0);

44538
        sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];

44539


44540
        /* set compiled values of dynamic vector attributes */

44541
        ssSetNumNonsampledZCs(childS, 0);

44542


44543
        /* Update connectivity flags for each port */

44544
        _ssSetInputPortConnected(childS, 0, 1);

44545
        _ssSetInputPortConnected(childS, 1, 1);

44546
        _ssSetInputPortConnected(childS, 2, 1);

44547
        _ssSetInputPortConnected(childS, 3, 1);

44548
        _ssSetOutputPortConnected(childS, 0, 1);

44549
        _ssSetOutputPortBeingMerged(childS, 0, 0);

44550


44551
        /* Update the BufferDstPort flags for each input port */

44552
        _ssSetInputPortBufferDstPort(childS, 0, -1);

44553
        _ssSetInputPortBufferDstPort(childS, 1, -1);

44554
        _ssSetInputPortBufferDstPort(childS, 2, -1);

44555
        _ssSetInputPortBufferDstPort(childS, 3, -1);

44556
      }

44557
    }

44558
  }

44559


44560
  return (NULL);

44561
}

44562